After adding additionnel configuration for validations

This commit is contained in:
Your Name 2026-09-15 13:42:57 +02:00
parent fd7d43035b
commit add1e69f5b
29 changed files with 2750 additions and 176 deletions

View File

@ -94,6 +94,8 @@ SWEEP_ENABLED=false
SWEEP_MIN_AMOUNT_RAW=1000000
# SWEEP_BSC_GAS_TOPUP_WEI=1000000000000000
# SWEEP_TRON_GAS_TOPUP_SUN=15000000
# Optional USDT left on hot after Hot→Cold (raw units; default 0). BEP20 18 dec / TRC20 6 dec.
# HOT_USDT_MIN_RESERVE_RAW=0
RATE_LIMIT_MAX=2000
# Ports dédiés Prediqo (n'utilise pas 80/443 du VPS)

View File

@ -197,6 +197,11 @@ export const config = {
sweepMinAmountRaw: process.env.SWEEP_MIN_AMOUNT_RAW || '1000000',
/** TRX sent from hot wallet to fund TRC20 sweeps (sun) */
tronGasTopUpSun: process.env.SWEEP_TRON_GAS_TOPUP_SUN || '15000000',
/**
* Min USDT (chain raw units) to leave on hot after Hot→Cold USDT transfer.
* Default 0 = no USDT floor (native withdrawal gas reserve still enforced).
*/
hotUsdtMinReserveRaw: (process.env.HOT_USDT_MIN_RESERVE_RAW || '0').trim() || '0',
/** MATIC sent from hot wallet to fund USDC sweeps (wei) */
polygonGasTopUpWei: process.env.SWEEP_POLYGON_GAS_TOPUP_WEI || '100000000000000000',
},

View File

@ -2,6 +2,7 @@ import { Response } from 'express';
import { AuthRequest } from '../middleware/auth';
import * as fundApprovalService from '../services/fundApprovalService';
import type { FundOperationStatus, FundOperationType } from '../repositories/fundOperationRequestRepository';
import type { PolicyInput } from '../repositories/approvalPolicyRepository';
export async function createFundRequest(req: AuthRequest, res: Response): Promise<void> {
try {
@ -31,12 +32,10 @@ export async function listFundRequests(req: AuthRequest, res: Response): Promise
const operationType = (req.query.operationType as FundOperationType) || undefined;
const limit = parseInt((req.query.limit as string) || '50', 10);
const offset = parseInt((req.query.offset as string) || '0', 10);
const result = await fundApprovalService.listFundRequests({
status,
operationType,
limit,
offset,
});
const result = await fundApprovalService.listFundRequests(
{ status, operationType, limit, offset },
req.user!.userId
);
res.json(result);
} catch (e) {
res.status(500).json({ error: e instanceof Error ? e.message : 'Failed to list requests' });
@ -45,7 +44,7 @@ export async function listFundRequests(req: AuthRequest, res: Response): Promise
export async function getFundRequest(req: AuthRequest, res: Response): Promise<void> {
try {
const result = await fundApprovalService.getFundRequest(req.params.id);
const result = await fundApprovalService.getFundRequest(req.params.id, req.user!.userId);
if (!result) {
res.status(404).json({ error: 'Request not found' });
return;
@ -94,3 +93,48 @@ export async function cancelFundRequest(req: AuthRequest, res: Response): Promis
res.status(400).json({ error: msg });
}
}
export async function listApprovalPolicies(req: AuthRequest, res: Response): Promise<void> {
try {
const items = await fundApprovalService.listApprovalPolicies(req.user!.userId);
res.json({ items });
} catch (e) {
const msg = e instanceof Error ? e.message : 'Failed to list policies';
res.status(msg.includes('Permission') ? 403 : 500).json({ error: msg });
}
}
export async function listPolicyRevisions(req: AuthRequest, res: Response): Promise<void> {
try {
const limit = parseInt((req.query.limit as string) || '50', 10);
const items = await fundApprovalService.listPolicyRevisions(req.user!.userId, limit);
res.json({ items });
} catch (e) {
const msg = e instanceof Error ? e.message : 'Failed to list revisions';
res.status(msg.includes('Permission') ? 403 : 500).json({ error: msg });
}
}
export async function draftPolicyChange(req: AuthRequest, res: Response): Promise<void> {
try {
const { after, note } = req.body as { after?: PolicyInput[]; note?: string };
if (!Array.isArray(after)) {
res.status(400).json({ error: 'after (policies array) is required' });
return;
}
const result = await fundApprovalService.draftPolicyChange({
after,
note,
requestedBy: req.user!.userId,
});
res.status(202).json({
requestId: result.id,
status: result.status,
message: 'Policy change submitted — approve under Approvals to apply',
request: result,
});
} catch (e) {
const msg = e instanceof Error ? e.message : 'Failed to draft policy change';
res.status(400).json({ error: msg });
}
}

View File

@ -139,6 +139,66 @@ export async function cancelFunding(req: AuthRequest, res: Response): Promise<vo
}
}
export async function previewHotToColdUsdt(req: AuthRequest, res: Response): Promise<void> {
try {
const walletTypeId = parseInt(String(req.query.walletTypeId ?? ''), 10);
if (!Number.isFinite(walletTypeId) || walletTypeId <= 0) {
res.status(400).json({ error: 'walletTypeId is required' });
return;
}
res.json(await treasuryService.previewHotToColdUsdt(walletTypeId));
} catch (e) {
res.status(400).json({ error: e instanceof Error ? e.message : 'Hot→Cold preview failed' });
}
}
export async function requestHotToColdUsdt(req: AuthRequest, res: Response): Promise<void> {
try {
const { walletTypeId, amount, notes } = req.body as {
walletTypeId?: number;
amount?: string | number;
notes?: string;
};
if (typeof walletTypeId !== 'number' || amount == null) {
res.status(400).json({ error: 'walletTypeId and amount are required' });
return;
}
const preview = await treasuryService.previewHotToColdUsdt(walletTypeId);
const amountRaw = BigInt(amount);
if (amountRaw <= 0n) {
res.status(400).json({ error: 'amount must be greater than zero' });
return;
}
if (!preview.gasOk) {
res.status(400).json({ error: preview.gasHint || 'Hot wallet has insufficient native gas' });
return;
}
if (amountRaw > BigInt(preview.maxSendable)) {
res.status(400).json({
error: `Amount exceeds max sendable after USDT reserve. Max: ${preview.maxSendable}`,
});
return;
}
const result = await fundApprovalService.createFundRequest({
operationType: 'treasury_hot_to_cold',
payload: {
walletTypeId,
amountRaw: amountRaw.toString(),
notes,
},
requestedBy: req.user!.userId,
});
res.status(202).json({
requestId: result.id,
status: result.status,
message:
'Hot→Cold USDT submitted — approve under Approvals; the platform will send from hot to cold',
});
} catch (e) {
res.status(400).json({ error: e instanceof Error ? e.message : 'Hot→Cold request failed' });
}
}
export async function listStuckDeposits(_req: AuthRequest, res: Response): Promise<void> {
try {
res.json(await treasuryService.listStuckDeposits());

View File

@ -178,6 +178,8 @@ export async function runMigrations(): Promise<void> {
await client.query(sql);
const { syncPermissionCatalog } = await import('../rbac/syncPermissions');
await syncPermissionCatalog();
const { ensureDefaultPoliciesSeeded } = await import('../repositories/approvalPolicyRepository');
await ensureDefaultPoliciesSeeded();
} finally {
client.release();
}

View File

@ -130,18 +130,26 @@ CREATE TABLE IF NOT EXISTS fund_operation_requests (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
operation_type VARCHAR(64) NOT NULL
CHECK (operation_type IN (
'ledger_credit', 'treasury_cold_to_hot', 'bonus_pool_fund', 'sweep_manual', 'sweep_batch',
'treasury_hot_to_cold_gas', 'treasury_cold_to_hot_gas'
'ledger_credit', 'treasury_cold_to_hot', 'treasury_hot_to_cold', 'bonus_pool_fund', 'sweep_manual', 'sweep_batch',
'treasury_hot_to_cold_gas', 'treasury_cold_to_hot_gas', 'user_withdrawal', 'approval_policy_change'
)),
status VARCHAR(32) NOT NULL DEFAULT 'pending_approval'
CHECK (status IN (
'pending_approval', 'approved', 'rejected', 'executed', 'failed', 'cancelled'
'pending_approval', 'approved', 'processing', 'confirmed', 'executed', 'failed', 'rejected', 'cancelled'
)),
payload JSONB NOT NULL DEFAULT '{}',
requested_by UUID NOT NULL REFERENCES users(id),
approved_by UUID REFERENCES users(id),
rejection_reason TEXT,
execution_result JSONB,
policy_id UUID,
policy_snapshot JSONB,
required_quorum JSONB,
amount_raw TEXT,
asset_code VARCHAR(64),
network VARCHAR(32),
from_address VARCHAR(255),
to_address VARCHAR(255),
created_at TIMESTAMPTZ DEFAULT NOW(),
approved_at TIMESTAMPTZ,
executed_at TIMESTAMPTZ
@ -155,10 +163,77 @@ ALTER TABLE fund_operation_requests DROP CONSTRAINT IF EXISTS fund_operation_req
ALTER TABLE fund_operation_requests
ADD CONSTRAINT fund_operation_requests_operation_type_check
CHECK (operation_type IN (
'ledger_credit', 'treasury_cold_to_hot', 'bonus_pool_fund', 'sweep_manual', 'sweep_batch',
'treasury_hot_to_cold_gas', 'treasury_cold_to_hot_gas'
'ledger_credit', 'treasury_cold_to_hot', 'treasury_hot_to_cold', 'bonus_pool_fund', 'sweep_manual', 'sweep_batch',
'treasury_hot_to_cold_gas', 'treasury_cold_to_hot_gas', 'user_withdrawal', 'approval_policy_change'
));
ALTER TABLE fund_operation_requests DROP CONSTRAINT IF EXISTS fund_operation_requests_status_check;
ALTER TABLE fund_operation_requests
ADD CONSTRAINT fund_operation_requests_status_check
CHECK (status IN (
'pending_approval', 'approved', 'processing', 'confirmed', 'executed', 'failed', 'rejected', 'cancelled'
));
ALTER TABLE fund_operation_requests ADD COLUMN IF NOT EXISTS policy_id UUID;
ALTER TABLE fund_operation_requests ADD COLUMN IF NOT EXISTS policy_snapshot JSONB;
ALTER TABLE fund_operation_requests ADD COLUMN IF NOT EXISTS required_quorum JSONB;
ALTER TABLE fund_operation_requests ADD COLUMN IF NOT EXISTS amount_raw TEXT;
ALTER TABLE fund_operation_requests ADD COLUMN IF NOT EXISTS asset_code VARCHAR(64);
ALTER TABLE fund_operation_requests ADD COLUMN IF NOT EXISTS network VARCHAR(32);
ALTER TABLE fund_operation_requests ADD COLUMN IF NOT EXISTS from_address VARCHAR(255);
ALTER TABLE fund_operation_requests ADD COLUMN IF NOT EXISTS to_address VARCHAR(255);
-- Configurable approval policies (N-of-M)
CREATE TABLE IF NOT EXISTS approval_policies (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
name VARCHAR(128) NOT NULL,
enabled BOOLEAN NOT NULL DEFAULT true,
priority INTEGER NOT NULL DEFAULT 100,
operation_type VARCHAR(64),
wallet_type_id INTEGER REFERENCES wallet_types(id),
network VARCHAR(32),
amount_min_raw TEXT,
amount_max_raw TEXT,
source_wallet_kind VARCHAR(16) NOT NULL DEFAULT 'any'
CHECK (source_wallet_kind IN ('hot', 'cold', 'hd', 'user', 'any')),
dest_wallet_kind VARCHAR(16) NOT NULL DEFAULT 'any'
CHECK (dest_wallet_kind IN ('hot', 'cold', 'hd', 'user', 'any')),
decision JSONB NOT NULL DEFAULT '{}',
version INTEGER NOT NULL DEFAULT 1,
updated_by UUID REFERENCES users(id),
created_at TIMESTAMPTZ DEFAULT NOW(),
updated_at TIMESTAMPTZ DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_approval_policies_enabled_priority
ON approval_policies(enabled, priority);
CREATE TABLE IF NOT EXISTS approval_policy_revisions (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
change_request_id UUID REFERENCES fund_operation_requests(id),
actor_id UUID REFERENCES users(id),
before_snapshot JSONB NOT NULL DEFAULT '[]',
after_snapshot JSONB NOT NULL DEFAULT '[]',
note TEXT,
created_at TIMESTAMPTZ DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_approval_policy_revisions_created
ON approval_policy_revisions(created_at DESC);
CREATE TABLE IF NOT EXISTS fund_operation_votes (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
request_id UUID NOT NULL REFERENCES fund_operation_requests(id) ON DELETE CASCADE,
voter_id UUID NOT NULL REFERENCES users(id),
decision VARCHAR(16) NOT NULL CHECK (decision IN ('approve', 'reject')),
reason TEXT,
voter_roles JSONB NOT NULL DEFAULT '[]',
created_at TIMESTAMPTZ DEFAULT NOW(),
UNIQUE (request_id, voter_id)
);
CREATE INDEX IF NOT EXISTS idx_fund_operation_votes_request ON fund_operation_votes(request_id);
-- Batched automatic deposit sweeps awaiting approval
CREATE TABLE IF NOT EXISTS deposit_sweep_batches (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),

View File

@ -11,7 +11,14 @@ export interface Transaction {
type: 'deposit' | 'withdrawal' | 'transfer';
amount: string;
fee: string;
status: 'pending' | 'confirming' | 'completed' | 'failed';
status:
| 'pending'
| 'pending_approval'
| 'broadcasting'
| 'confirming'
| 'completed'
| 'failed'
| 'ledger_finalize_failed';
blockchain_tx_id: string | null;
from_address: string | null;
to_address: string | null;

View File

@ -65,6 +65,20 @@ export const PERMISSION_CATALOG: PermissionDef[] = [
resource: 'fund_operations',
action: 'approve',
},
{
key: 'approval_policy.view',
description: 'View approval policies and revision history',
category: 'fund_operations',
resource: 'approval_policies',
action: 'view',
},
{
key: 'approval_policy.manage',
description: 'Submit approval policy changes for Approvals',
category: 'fund_operations',
resource: 'approval_policies',
action: 'manage',
},
{
key: 'user.manage_roles',
description: 'Assign roles and manage RBAC',
@ -169,6 +183,8 @@ export const PERMISSION_CATALOG: PermissionDef[] = [
// Granular — fund operations
p('fund_operations', 'request', 'Submit fund operation requests', 'fund_operations', ['fund_operation.request']),
p('fund_operations', 'approve', 'Approve fund operations', 'fund_operations', ['fund_operation.approve']),
p('approval_policies', 'view', 'View approval policies', 'fund_operations', ['approval_policy.view']),
p('approval_policies', 'manage', 'Manage approval policies', 'fund_operations', ['approval_policy.manage']),
// Granular — ledger
p('ledger_credit', 'manage', 'Grant ledger credits to users', 'users', ['ledger.credit']),

View File

@ -0,0 +1,229 @@
/**
* Approval policies — configurable N-of-M rules for sensitive fund operations.
*/
import { query } from '../db/connection';
export type WalletKind = 'hot' | 'cold' | 'hd' | 'user' | 'any';
export type QuorumSlot = {
role?: string;
permission?: string;
count: number;
};
export type PolicyDecision = {
mode: 'auto_execute' | 'require_approvals';
quorum: QuorumSlot[];
forbid_self_approve: boolean;
require_distinct_users?: boolean;
};
export type ApprovalPolicyRow = {
id: string;
name: string;
enabled: boolean;
priority: number;
operation_type: string | null;
wallet_type_id: number | null;
network: string | null;
amount_min_raw: string | null;
amount_max_raw: string | null;
source_wallet_kind: WalletKind;
dest_wallet_kind: WalletKind;
decision: PolicyDecision;
version: number;
updated_by: string | null;
created_at: Date;
updated_at: Date;
};
export type ApprovalPolicyRevisionRow = {
id: string;
change_request_id: string | null;
actor_id: string | null;
before_snapshot: unknown;
after_snapshot: unknown;
note: string | null;
created_at: Date;
};
function normalizeDecision(raw: unknown): PolicyDecision {
const d = (raw && typeof raw === 'object' ? raw : {}) as Partial<PolicyDecision>;
const quorum = Array.isArray(d.quorum)
? d.quorum
.map((s) => ({
role: typeof s?.role === 'string' ? s.role : undefined,
permission: typeof s?.permission === 'string' ? s.permission : undefined,
count: Math.max(1, Number(s?.count) || 1),
}))
.filter((s) => s.role || s.permission)
: [];
return {
mode: d.mode === 'auto_execute' ? 'auto_execute' : 'require_approvals',
quorum,
forbid_self_approve: d.forbid_self_approve !== false,
require_distinct_users: d.require_distinct_users !== false,
};
}
function mapRow(row: Record<string, unknown>): ApprovalPolicyRow {
return {
id: String(row.id),
name: String(row.name),
enabled: Boolean(row.enabled),
priority: Number(row.priority),
operation_type: row.operation_type != null ? String(row.operation_type) : null,
wallet_type_id: row.wallet_type_id != null ? Number(row.wallet_type_id) : null,
network: row.network != null ? String(row.network) : null,
amount_min_raw: row.amount_min_raw != null ? String(row.amount_min_raw) : null,
amount_max_raw: row.amount_max_raw != null ? String(row.amount_max_raw) : null,
source_wallet_kind: (row.source_wallet_kind as WalletKind) || 'any',
dest_wallet_kind: (row.dest_wallet_kind as WalletKind) || 'any',
decision: normalizeDecision(row.decision),
version: Number(row.version ?? 1),
updated_by: row.updated_by != null ? String(row.updated_by) : null,
created_at: row.created_at as Date,
updated_at: row.updated_at as Date,
};
}
export async function listEnabledPolicies(): Promise<ApprovalPolicyRow[]> {
const rows = await query<Record<string, unknown>[]>(
`SELECT * FROM approval_policies WHERE enabled = true ORDER BY priority ASC, created_at ASC`
);
return rows.map(mapRow);
}
export async function listAllPolicies(): Promise<ApprovalPolicyRow[]> {
const rows = await query<Record<string, unknown>[]>(
`SELECT * FROM approval_policies ORDER BY priority ASC, created_at ASC`
);
return rows.map(mapRow);
}
export async function findById(id: string): Promise<ApprovalPolicyRow | null> {
const rows = await query<Record<string, unknown>[]>(
`SELECT * FROM approval_policies WHERE id = $1`,
[id]
);
return rows[0] ? mapRow(rows[0]) : null;
}
export async function countPolicies(): Promise<number> {
const rows = await query<{ count: string }[]>(
`SELECT COUNT(*)::text AS count FROM approval_policies`
);
return parseInt(rows[0]?.count ?? '0', 10);
}
export type PolicyInput = {
name: string;
enabled?: boolean;
priority?: number;
operationType?: string | null;
walletTypeId?: number | null;
network?: string | null;
amountMinRaw?: string | null;
amountMaxRaw?: string | null;
sourceWalletKind?: WalletKind;
destWalletKind?: WalletKind;
decision: PolicyDecision;
};
export async function replaceAllPolicies(
policies: PolicyInput[],
updatedBy: string | null
): Promise<ApprovalPolicyRow[]> {
await query(`DELETE FROM approval_policies`);
const out: ApprovalPolicyRow[] = [];
for (const p of policies) {
const rows = await query<Record<string, unknown>[]>(
`INSERT INTO approval_policies (
name, enabled, priority, operation_type, wallet_type_id, network,
amount_min_raw, amount_max_raw, source_wallet_kind, dest_wallet_kind,
decision, version, updated_by, updated_at
) VALUES (
$1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11::jsonb, 1, $12, NOW()
) RETURNING *`,
[
p.name,
p.enabled !== false,
p.priority ?? 100,
p.operationType ?? null,
p.walletTypeId ?? null,
p.network ?? null,
p.amountMinRaw ?? null,
p.amountMaxRaw ?? null,
p.sourceWalletKind ?? 'any',
p.destWalletKind ?? 'any',
JSON.stringify(normalizeDecision(p.decision)),
updatedBy,
]
);
out.push(mapRow(rows[0]));
}
return out;
}
export async function insertRevision(input: {
changeRequestId?: string | null;
actorId: string | null;
beforeSnapshot: unknown;
afterSnapshot: unknown;
note?: string | null;
}): Promise<ApprovalPolicyRevisionRow> {
const rows = await query<ApprovalPolicyRevisionRow[]>(
`INSERT INTO approval_policy_revisions (
change_request_id, actor_id, before_snapshot, after_snapshot, note
) VALUES ($1, $2, $3::jsonb, $4::jsonb, $5)
RETURNING *`,
[
input.changeRequestId ?? null,
input.actorId,
JSON.stringify(input.beforeSnapshot ?? []),
JSON.stringify(input.afterSnapshot ?? []),
input.note ?? null,
]
);
return rows[0];
}
export async function listRevisions(limit = 50): Promise<ApprovalPolicyRevisionRow[]> {
return query<ApprovalPolicyRevisionRow[]>(
`SELECT * FROM approval_policy_revisions ORDER BY created_at DESC LIMIT $1`,
[Math.min(limit, 200)]
);
}
/** Default fail-closed + current-platform behavior seed. */
export function defaultPolicySeed(): PolicyInput[] {
const superAdminQuorum: PolicyDecision = {
mode: 'require_approvals',
quorum: [{ role: 'super_admin', count: 1 }],
forbid_self_approve: true,
require_distinct_users: true,
};
return [
{
name: 'Default — all fund ops (1 Super Admin)',
enabled: true,
priority: 1000,
operationType: null,
decision: superAdminQuorum,
},
{
name: 'Approval policy changes (1 other Super Admin)',
enabled: true,
priority: 10,
operationType: 'approval_policy_change',
decision: superAdminQuorum,
},
];
}
export async function ensureDefaultPoliciesSeeded(): Promise<void> {
const count = await countPolicies();
if (count > 0) return;
await replaceAllPolicies(defaultPolicySeed(), null);
}

View File

@ -7,18 +7,23 @@ import { query } from '../db/connection';
export type FundOperationType =
| 'ledger_credit'
| 'treasury_cold_to_hot'
| 'treasury_hot_to_cold'
| 'bonus_pool_fund'
| 'sweep_manual'
| 'sweep_batch'
| 'treasury_hot_to_cold_gas'
| 'treasury_cold_to_hot_gas';
| 'treasury_cold_to_hot_gas'
| 'user_withdrawal'
| 'approval_policy_change';
export type FundOperationStatus =
| 'pending_approval'
| 'approved'
| 'rejected'
| 'processing'
| 'confirmed'
| 'executed'
| 'failed'
| 'rejected'
| 'cancelled';
export type FundOperationRequestRow = {
@ -30,23 +35,68 @@ export type FundOperationRequestRow = {
approved_by: string | null;
rejection_reason: string | null;
execution_result: Record<string, unknown> | null;
policy_id: string | null;
policy_snapshot: Record<string, unknown> | null;
required_quorum: unknown[] | null;
amount_raw: string | null;
asset_code: string | null;
network: string | null;
from_address: string | null;
to_address: string | null;
created_at: Date;
approved_at: Date | null;
executed_at: Date | null;
};
export type CreateFundRequestMeta = {
policyId?: string | null;
policySnapshot?: Record<string, unknown> | null;
requiredQuorum?: unknown[] | null;
amountRaw?: string | null;
assetCode?: string | null;
network?: string | null;
fromAddress?: string | null;
toAddress?: string | null;
};
function normalizeRow(row: FundOperationRequestRow): FundOperationRequestRow {
if (row.status === 'executed') {
return { ...row, status: 'confirmed' };
}
return row;
}
export async function createRequest(input: {
operationType: FundOperationType;
payload: Record<string, unknown>;
requestedBy: string;
meta?: CreateFundRequestMeta;
}): Promise<FundOperationRequestRow> {
const m = input.meta ?? {};
const rows = await query<FundOperationRequestRow[]>(
`INSERT INTO fund_operation_requests (operation_type, payload, requested_by)
VALUES ($1, $2::jsonb, $3)
`INSERT INTO fund_operation_requests (
operation_type, payload, requested_by,
policy_id, policy_snapshot, required_quorum,
amount_raw, asset_code, network, from_address, to_address
) VALUES (
$1, $2::jsonb, $3, $4, $5::jsonb, $6::jsonb, $7, $8, $9, $10, $11
)
RETURNING *`,
[input.operationType, JSON.stringify(input.payload), input.requestedBy]
[
input.operationType,
JSON.stringify(input.payload),
input.requestedBy,
m.policyId ?? null,
m.policySnapshot != null ? JSON.stringify(m.policySnapshot) : null,
m.requiredQuorum != null ? JSON.stringify(m.requiredQuorum) : null,
m.amountRaw ?? null,
m.assetCode ?? null,
m.network ?? null,
m.fromAddress ?? null,
m.toAddress ?? null,
]
);
return rows[0];
return normalizeRow(rows[0]);
}
export async function findById(id: string): Promise<FundOperationRequestRow | null> {
@ -54,7 +104,7 @@ export async function findById(id: string): Promise<FundOperationRequestRow | nu
`SELECT * FROM fund_operation_requests WHERE id = $1`,
[id]
);
return rows[0] ?? null;
return rows[0] ? normalizeRow(rows[0]) : null;
}
export async function listRequests(filters: {
@ -67,8 +117,12 @@ export async function listRequests(filters: {
const values: unknown[] = [];
let i = 1;
if (filters.status) {
where.push(`status = $${i++}`);
values.push(filters.status);
if (filters.status === 'confirmed') {
where.push(`status IN ('confirmed', 'executed')`);
} else {
where.push(`status = $${i++}`);
values.push(filters.status);
}
}
if (filters.operationType) {
where.push(`operation_type = $${i++}`);
@ -88,7 +142,7 @@ export async function listRequests(filters: {
LIMIT $${i++} OFFSET $${i}`,
[...values, limit, offset]
);
return { items, total: parseInt(countRows[0]?.count ?? '0', 10) };
return { items: items.map(normalizeRow), total: parseInt(countRows[0]?.count ?? '0', 10) };
}
export async function markApproved(id: string, approvedBy: string): Promise<FundOperationRequestRow | null> {
@ -99,7 +153,18 @@ export async function markApproved(id: string, approvedBy: string): Promise<Fund
RETURNING *`,
[id, approvedBy]
);
return rows[0] ?? null;
return rows[0] ? normalizeRow(rows[0]) : null;
}
export async function markProcessing(id: string): Promise<FundOperationRequestRow | null> {
const rows = await query<FundOperationRequestRow[]>(
`UPDATE fund_operation_requests
SET status = 'processing'
WHERE id = $1 AND status IN ('approved', 'pending_approval')
RETURNING *`,
[id]
);
return rows[0] ? normalizeRow(rows[0]) : null;
}
export async function markRejected(
@ -114,16 +179,24 @@ export async function markRejected(
RETURNING *`,
[id, approvedBy, reason]
);
return rows[0] ?? null;
return rows[0] ? normalizeRow(rows[0]) : null;
}
/** @deprecated prefer markConfirmed — kept for callers; writes status confirmed */
export async function markExecuted(
id: string,
executionResult: Record<string, unknown>
): Promise<void> {
await markConfirmed(id, executionResult);
}
export async function markConfirmed(
id: string,
executionResult: Record<string, unknown>
): Promise<void> {
await query(
`UPDATE fund_operation_requests
SET status = 'executed', executed_at = NOW(), execution_result = $2::jsonb
SET status = 'confirmed', executed_at = NOW(), execution_result = $2::jsonb
WHERE id = $1`,
[id, JSON.stringify(executionResult)]
);
@ -146,5 +219,14 @@ export async function markCancelled(id: string): Promise<FundOperationRequestRow
RETURNING *`,
[id]
);
return rows[0] ?? null;
return rows[0] ? normalizeRow(rows[0]) : null;
}
export async function touchApprovedBy(id: string, approvedBy: string): Promise<void> {
await query(
`UPDATE fund_operation_requests
SET approved_by = $2, approved_at = COALESCE(approved_at, NOW())
WHERE id = $1`,
[id, approvedBy]
);
}

View File

@ -0,0 +1,76 @@
/**
* Votes on fund operation approval requests (N-of-M).
*/
import { query } from '../db/connection';
export type VoteDecision = 'approve' | 'reject';
export type FundOperationVoteRow = {
id: string;
request_id: string;
voter_id: string;
decision: VoteDecision;
reason: string | null;
voter_roles: string[];
created_at: Date;
};
function mapRow(row: Record<string, unknown>): FundOperationVoteRow {
const rolesRaw = row.voter_roles;
const roles = Array.isArray(rolesRaw)
? rolesRaw.map(String)
: typeof rolesRaw === 'string'
? (JSON.parse(rolesRaw) as string[])
: [];
return {
id: String(row.id),
request_id: String(row.request_id),
voter_id: String(row.voter_id),
decision: row.decision as VoteDecision,
reason: row.reason != null ? String(row.reason) : null,
voter_roles: roles,
created_at: row.created_at as Date,
};
}
export async function listByRequest(requestId: string): Promise<FundOperationVoteRow[]> {
const rows = await query<Record<string, unknown>[]>(
`SELECT * FROM fund_operation_votes WHERE request_id = $1 ORDER BY created_at ASC`,
[requestId]
);
return rows.map(mapRow);
}
export async function findByRequestAndVoter(
requestId: string,
voterId: string
): Promise<FundOperationVoteRow | null> {
const rows = await query<Record<string, unknown>[]>(
`SELECT * FROM fund_operation_votes WHERE request_id = $1 AND voter_id = $2`,
[requestId, voterId]
);
return rows[0] ? mapRow(rows[0]) : null;
}
export async function insertVote(input: {
requestId: string;
voterId: string;
decision: VoteDecision;
reason?: string | null;
voterRoles: string[];
}): Promise<FundOperationVoteRow> {
const rows = await query<Record<string, unknown>[]>(
`INSERT INTO fund_operation_votes (request_id, voter_id, decision, reason, voter_roles)
VALUES ($1, $2, $3, $4, $5::jsonb)
RETURNING *`,
[
input.requestId,
input.voterId,
input.decision,
input.reason ?? null,
JSON.stringify(input.voterRoles),
]
);
return mapRow(rows[0]);
}

View File

@ -35,6 +35,7 @@ import {
adminLedgerCreditBodySchema,
fundRequestCreateBodySchema,
fundRequestRejectBodySchema,
approvalPolicyDraftBodySchema,
securityAlertResolveBodySchema,
securitySettingsBodySchema,
adminUserSecurityBodySchema,
@ -322,6 +323,25 @@ router.delete(
requirePermissions('fund_operation.request'),
fundApprovalController.cancelFundRequest
);
router.get(
'/admin/approval-policies',
requireRoles('admin'),
requirePermissions('approval_policy.view'),
fundApprovalController.listApprovalPolicies
);
router.get(
'/admin/approval-policies/revisions',
requireRoles('admin'),
requirePermissions('approval_policy.view'),
fundApprovalController.listPolicyRevisions
);
router.post(
'/admin/approval-policies/draft-change',
requireRoles('admin'),
requirePermissions('approval_policy.manage'),
validateBody(approvalPolicyDraftBodySchema),
fundApprovalController.draftPolicyChange
);
router.post(
'/admin/users/:userId/verify-email',
requireRoles('admin'),
@ -474,6 +494,8 @@ router.get('/admin/treasury/sweeps', requireRoles('admin'), requirePermissions('
router.post('/admin/treasury/sweeps/run', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.runSweeps);
router.get('/admin/treasury/funding', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.listFunding);
router.post('/admin/treasury/funding', requireRoles('admin'), requirePermissions('treasury.view'), validateBody(treasuryFundingBodySchema), treasuryController.requestFunding);
router.get('/admin/treasury/funding/hot-to-cold/preview', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.previewHotToColdUsdt);
router.post('/admin/treasury/funding/hot-to-cold', requireRoles('admin'), requirePermissions('treasury.view'), validateBody(treasuryFundingBodySchema), treasuryController.requestHotToColdUsdt);
router.patch('/admin/treasury/funding/:fundingId/confirm', requireRoles('admin'), requirePermissions('treasury.view'), validateBody(treasuryFundingConfirmBodySchema), treasuryController.confirmFunding);
router.delete('/admin/treasury/funding/:fundingId', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.cancelFunding);
router.get('/admin/treasury/stuck-deposits', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.listStuckDeposits);

View File

@ -0,0 +1,208 @@
/**
* Evaluates configurable approval policies (N-of-M / auto-execute).
*/
import * as approvalPolicyRepository from '../repositories/approvalPolicyRepository';
import type {
ApprovalPolicyRow,
PolicyDecision,
QuorumSlot,
WalletKind,
} from '../repositories/approvalPolicyRepository';
import type { FundOperationType } from '../repositories/fundOperationRequestRepository';
import type { FundOperationVoteRow } from '../repositories/fundOperationVoteRepository';
export type EvaluateInput = {
operationType: FundOperationType | string;
amountRaw?: string | null;
walletTypeId?: number | null;
network?: string | null;
sourceKind?: WalletKind;
destKind?: WalletKind;
};
export type EvaluateResult = {
policy: ApprovalPolicyRow | null;
decision: PolicyDecision;
matchedBy: 'policy' | 'fail_closed_default';
};
const FAIL_CLOSED: PolicyDecision = {
mode: 'require_approvals',
quorum: [{ role: 'super_admin', count: 1 }],
forbid_self_approve: true,
require_distinct_users: true,
};
function kindMatches(rule: WalletKind, actual: WalletKind | undefined): boolean {
if (rule === 'any') return true;
if (!actual || actual === 'any') return true;
return rule === actual;
}
function amountInRange(
amountRaw: string | null | undefined,
minRaw: string | null,
maxRaw: string | null
): boolean {
if (amountRaw == null || amountRaw === '') {
return minRaw == null && maxRaw == null;
}
let amount: bigint;
try {
amount = BigInt(amountRaw);
} catch {
return false;
}
if (minRaw != null && minRaw !== '') {
try {
if (amount < BigInt(minRaw)) return false;
} catch {
return false;
}
}
if (maxRaw != null && maxRaw !== '') {
try {
if (amount > BigInt(maxRaw)) return false;
} catch {
return false;
}
}
return true;
}
export function policyMatches(policy: ApprovalPolicyRow, input: EvaluateInput): boolean {
if (!policy.enabled) return false;
if (policy.operation_type && policy.operation_type !== input.operationType) return false;
if (policy.wallet_type_id != null && policy.wallet_type_id !== input.walletTypeId) return false;
if (policy.network && policy.network !== input.network) return false;
if (!kindMatches(policy.source_wallet_kind, input.sourceKind)) return false;
if (!kindMatches(policy.dest_wallet_kind, input.destKind)) return false;
if (!amountInRange(input.amountRaw, policy.amount_min_raw, policy.amount_max_raw)) return false;
return true;
}
export async function evaluate(input: EvaluateInput): Promise<EvaluateResult> {
await approvalPolicyRepository.ensureDefaultPoliciesSeeded();
const policies = await approvalPolicyRepository.listEnabledPolicies();
for (const policy of policies) {
if (policyMatches(policy, input)) {
return {
policy,
decision: policy.decision,
matchedBy: 'policy',
};
}
}
return {
policy: null,
decision: FAIL_CLOSED,
matchedBy: 'fail_closed_default',
};
}
/** True if approve votes satisfy every quorum slot. */
export function quorumSatisfied(
quorum: QuorumSlot[],
approveVotes: FundOperationVoteRow[],
voterHasRole: (voterId: string, role: string) => boolean,
voterHasPermission: (voterId: string, permission: string) => boolean
): boolean {
if (!quorum.length) return false;
const used = new Set<string>();
for (const slot of quorum) {
let filled = 0;
for (const vote of approveVotes) {
if (used.has(vote.voter_id)) continue;
const roleOk = slot.role ? voterHasRole(vote.voter_id, slot.role) || vote.voter_roles.includes(slot.role) : false;
const permOk = slot.permission ? voterHasPermission(vote.voter_id, slot.permission) : false;
// Prefer roles recorded on the vote; async permission checked by caller via cache map
const ok = slot.role
? vote.voter_roles.includes(slot.role) || roleOk
: permOk;
if (!ok && slot.permission) {
// permission checked externally — caller passes precomputed eligibility
continue;
}
if (slot.role && !vote.voter_roles.includes(slot.role)) continue;
if (!slot.role && slot.permission) {
// handled below with permission set on vote metadata — skip if only permission and not in roles
continue;
}
filled += 1;
used.add(vote.voter_id);
if (filled >= slot.count) break;
}
if (filled < slot.count) return false;
}
return true;
}
/**
* Count how many approve votes fill each slot (role-based; permission slots need prefilter).
*/
export function countQuorumProgress(
quorum: QuorumSlot[],
approveVotes: FundOperationVoteRow[]
): { required: number; approved: number; slots: Array<{ slot: QuorumSlot; filled: number; needed: number }> } {
const used = new Set<string>();
const slots = quorum.map((slot) => {
let filled = 0;
for (const vote of approveVotes) {
if (used.has(vote.voter_id)) continue;
const matchesRole = slot.role ? vote.voter_roles.includes(slot.role) : false;
const matchesPerm =
slot.permission && !slot.role
? vote.voter_roles.includes(`perm:${slot.permission}`) ||
vote.voter_roles.includes(slot.permission)
: false;
if (!matchesRole && !matchesPerm) continue;
filled += 1;
used.add(vote.voter_id);
if (filled >= slot.count) break;
}
return { slot, filled, needed: slot.count };
});
const required = slots.reduce((s, x) => s + x.needed, 0);
const approved = slots.reduce((s, x) => s + Math.min(x.filled, x.needed), 0);
return { required, approved, slots };
}
export function isQuorumComplete(
quorum: QuorumSlot[],
approveVotes: FundOperationVoteRow[]
): boolean {
const progress = countQuorumProgress(quorum, approveVotes);
return progress.slots.every((s) => s.filled >= s.needed);
}
/** Whether voter can contribute to any unfilled quorum slot. */
export function voterFillsOpenSlot(
quorum: QuorumSlot[],
approveVotes: FundOperationVoteRow[],
voterRoles: string[],
voterPermissions: string[]
): boolean {
const progress = countQuorumProgress(quorum, approveVotes);
for (const { slot, filled, needed } of progress.slots) {
if (filled >= needed) continue;
if (slot.role && voterRoles.includes(slot.role)) return true;
if (slot.permission && voterPermissions.includes(slot.permission)) return true;
if (slot.permission && voterPermissions.includes(`admin.${slot.permission}`)) return true;
}
return false;
}
export function annotateVoterRolesForQuorum(
roles: string[],
permissions: string[],
quorum: QuorumSlot[]
): string[] {
const out = [...roles];
for (const slot of quorum) {
if (slot.permission && permissions.includes(slot.permission)) {
out.push(`perm:${slot.permission}`);
}
}
return [...new Set(out)];
}

View File

@ -1,5 +1,5 @@
/**
* Super-admin approval workflow for sensitive platform fund operations.
* Approval workflow for sensitive platform fund operations (N-of-M + auto-execute).
*/
import * as fundOperationRequestRepository from '../repositories/fundOperationRequestRepository';
@ -8,8 +8,10 @@ import type {
FundOperationStatus,
FundOperationType,
} from '../repositories/fundOperationRequestRepository';
import * as fundOperationVoteRepository from '../repositories/fundOperationVoteRepository';
import * as approvalPolicyRepository from '../repositories/approvalPolicyRepository';
import type { PolicyDecision, PolicyInput, QuorumSlot } from '../repositories/approvalPolicyRepository';
import * as roleRepository from '../repositories/roleRepository';
import * as userRepository from '../repositories/userRepository';
import { bumpUserTokenOnRoleChange } from './rbacService';
import * as auditLogRepository from '../repositories/auditLogRepository';
import * as securityNotificationService from './securityNotificationService';
@ -17,7 +19,8 @@ import * as adminCreditService from './adminCreditService';
import * as treasuryService from './treasuryService';
import * as bonusPoolRepository from '../repositories/bonusPoolRepository';
import * as sweepService from './sweepService';
import * as depositSweepBatchRepository from '../repositories/depositSweepBatchRepository';
import * as approvalPolicyEngine from './approvalPolicyEngine';
import type { WalletKind } from '../repositories/approvalPolicyRepository';
import type { RoleName } from '../models';
export class FundApprovalError extends Error {
@ -27,6 +30,14 @@ export class FundApprovalError extends Error {
}
}
export type FundRequestVoteDto = {
voterId: string;
decision: 'approve' | 'reject';
reason: string | null;
voterRoles: string[];
createdAt: string;
};
export type FundRequestDto = {
id: string;
operationType: FundOperationType;
@ -39,9 +50,57 @@ export type FundRequestDto = {
createdAt: string;
approvedAt: string | null;
executedAt: string | null;
policyId: string | null;
policyName: string | null;
requiredQuorum: QuorumSlot[];
forbidSelfApprove: boolean;
amountRaw: string | null;
assetCode: string | null;
network: string | null;
fromAddress: string | null;
toAddress: string | null;
votes: FundRequestVoteDto[];
quorumProgress: { required: number; approved: number };
canVote: boolean;
};
function toDto(row: FundOperationRequestRow): FundRequestDto {
async function toDto(
row: FundOperationRequestRow,
viewerId?: string | null
): Promise<FundRequestDto> {
const votes = await fundOperationVoteRepository.listByRequest(row.id);
const decision = (row.policy_snapshot as PolicyDecision | null) ?? {
mode: 'require_approvals' as const,
quorum: (row.required_quorum as QuorumSlot[]) ?? [{ role: 'super_admin', count: 1 }],
forbid_self_approve: true,
};
const quorum = Array.isArray(decision.quorum) ? decision.quorum : [];
const approveVotes = votes.filter((v) => v.decision === 'approve');
const progress = approvalPolicyEngine.countQuorumProgress(quorum, approveVotes);
let policyName: string | null = null;
if (row.policy_id) {
const p = await approvalPolicyRepository.findById(row.policy_id);
policyName = p?.name ?? null;
}
let canVote = false;
if (viewerId && row.status === 'pending_approval') {
const existing = votes.find((v) => v.voter_id === viewerId);
if (!existing) {
if (decision.forbid_self_approve && viewerId === row.requested_by) {
canVote = false;
} else {
const roles = await roleRepository.getUserRoleNames(viewerId);
const perms = await roleRepository.getUserPermissions(viewerId);
const hasApprovePerm = perms.includes('fund_operation.approve');
canVote =
hasApprovePerm &&
approvalPolicyEngine.voterFillsOpenSlot(quorum, approveVotes, roles, perms);
}
}
}
return {
id: row.id,
operationType: row.operation_type,
@ -54,49 +113,63 @@ function toDto(row: FundOperationRequestRow): FundRequestDto {
createdAt: row.created_at.toISOString(),
approvedAt: row.approved_at?.toISOString() ?? null,
executedAt: row.executed_at?.toISOString() ?? null,
policyId: row.policy_id,
policyName,
requiredQuorum: quorum,
forbidSelfApprove: decision.forbid_self_approve !== false,
amountRaw: row.amount_raw,
assetCode: row.asset_code,
network: row.network,
fromAddress: row.from_address,
toAddress: row.to_address,
votes: votes.map((v) => ({
voterId: v.voter_id,
decision: v.decision,
reason: v.reason,
voterRoles: v.voter_roles,
createdAt: v.created_at.toISOString(),
})),
quorumProgress: { required: progress.required, approved: progress.approved },
canVote,
};
}
export async function createFundRequest(input: {
operationType: FundOperationType;
payload: Record<string, unknown>;
requestedBy: string;
}): Promise<FundRequestDto> {
const canRequest = await roleRepository.userHasPermission(
input.requestedBy,
'fund_operation.request'
);
if (!canRequest) throw new FundApprovalError('Permission denied: fund_operation.request');
function extractContext(operationType: FundOperationType, payload: Record<string, unknown>) {
const amountRaw =
(payload.amountRaw as string | undefined) ??
(payload.amount as string | undefined) ??
null;
const walletTypeId =
typeof payload.walletTypeId === 'number'
? payload.walletTypeId
: payload.walletTypeId != null
? Number(payload.walletTypeId)
: null;
const network = (payload.network as string | undefined) ?? null;
const assetCode = (payload.assetCode as string | undefined) ?? (payload.walletCode as string | undefined) ?? null;
const fromAddress = (payload.fromAddress as string | undefined) ?? null;
const toAddress = (payload.toAddress as string | undefined) ?? null;
let row;
try {
row = await fundOperationRequestRepository.createRequest({
operationType: input.operationType,
payload: input.payload,
requestedBy: input.requestedBy,
});
} catch (e) {
const msg = e instanceof Error ? e.message : '';
if (/operation_type_check|violates check constraint/i.test(msg)) {
throw new FundApprovalError(
'Database schema is missing this operation type. Run db migrations and restart the backend.'
);
}
throw e;
let sourceKind: WalletKind = 'any';
let destKind: WalletKind = 'any';
if (operationType === 'treasury_hot_to_cold' || operationType === 'treasury_hot_to_cold_gas') {
sourceKind = 'hot';
destKind = 'cold';
} else if (operationType === 'treasury_cold_to_hot' || operationType === 'treasury_cold_to_hot_gas') {
sourceKind = 'cold';
destKind = 'hot';
} else if (operationType === 'sweep_batch' || operationType === 'sweep_manual') {
sourceKind = 'hd';
destKind = 'cold';
} else if (operationType === 'user_withdrawal') {
sourceKind = 'hot';
destKind = 'user';
}
await auditLogRepository.create({
userId: input.requestedBy,
action: 'fund_operation_requested',
resourceType: 'fund_operation_request',
resourceId: row.id,
metadata: { operation_type: input.operationType },
});
return toDto(row);
return { amountRaw, walletTypeId, network, assetCode, fromAddress, toAddress, sourceKind, destKind };
}
async function executeApprovedRequest(
export async function executeApprovedRequest(
request: FundOperationRequestRow,
approverId: string
): Promise<Record<string, unknown>> {
@ -111,7 +184,7 @@ async function executeApprovedRequest(
amountRaw: string;
reason: string;
};
const result = await adminCreditService.grantLedgerCredit({
return adminCreditService.grantLedgerCredit({
userId,
walletTypeId,
adjustmentType,
@ -120,7 +193,6 @@ async function executeApprovedRequest(
approvedBy,
requestedBy: request.requested_by,
});
return result;
}
case 'treasury_cold_to_hot': {
const { walletTypeId, amountRaw, notes } = request.payload as {
@ -128,13 +200,12 @@ async function executeApprovedRequest(
amountRaw: string;
notes?: string;
};
const result = await treasuryService.requestColdToHotFunding(request.requested_by, {
return treasuryService.requestColdToHotFunding(request.requested_by, {
walletTypeId,
amountRaw: BigInt(amountRaw),
notes,
approvedBy,
});
return result;
}
case 'bonus_pool_fund': {
const { walletTypeId, amountRaw } = request.payload as {
@ -147,7 +218,6 @@ async function executeApprovedRequest(
return { message: 'Pool funded', pools };
}
case 'sweep_manual': {
// Legacy: promote open batches to Approvals; also run any rare unbatched pending rows.
const { createSweepBatchApprovalRequests } = await import('./sweepBatchService');
const batchesSubmitted = await createSweepBatchApprovalRequests();
const processedUnbatched = await sweepService.processPendingSweeps({ unbatchedOnly: true });
@ -172,6 +242,20 @@ async function executeApprovedRequest(
approvedBy,
});
}
case 'treasury_hot_to_cold': {
const { walletTypeId, amountRaw, notes } = request.payload as {
walletTypeId: number;
amountRaw: string;
notes?: string;
};
return treasuryService.executeHotToColdUsdt({
walletTypeId,
amountRaw: BigInt(amountRaw),
notes,
requestedBy: request.requested_by,
approvedBy,
});
}
case 'treasury_cold_to_hot_gas': {
const { walletTypeId, amountRaw, notes } = request.payload as {
walletTypeId: number;
@ -185,16 +269,198 @@ async function executeApprovedRequest(
approvedBy,
});
}
case 'user_withdrawal': {
const { broadcastApprovedWithdrawal } = await import('./withdrawalService');
const { transactionId } = request.payload as { transactionId: string };
return broadcastApprovedWithdrawal(transactionId, approvedBy);
}
case 'approval_policy_change': {
return applyPolicyChangeFromRequest(request, approvedBy);
}
default:
throw new FundApprovalError(`Unknown operation type: ${request.operation_type}`);
throw new FundApprovalError(`Unknown operation type: ${(request as FundOperationRequestRow).operation_type}`);
}
}
export async function approveFundRequest(
async function applyPolicyChangeFromRequest(
request: FundOperationRequestRow,
actorId: string
): Promise<Record<string, unknown>> {
const { after, note } = request.payload as {
after: PolicyInput[];
note?: string;
};
if (!Array.isArray(after) || !after.length) {
throw new FundApprovalError('approval_policy_change payload.after must be a non-empty array');
}
const before = await approvalPolicyRepository.listAllPolicies();
const applied = await approvalPolicyRepository.replaceAllPolicies(after, actorId);
await approvalPolicyRepository.insertRevision({
changeRequestId: request.id,
actorId,
beforeSnapshot: before,
afterSnapshot: applied,
note: note ?? null,
});
await auditLogRepository.create({
userId: actorId,
action: 'approval_policies_applied',
resourceType: 'approval_policy',
resourceId: request.id,
metadata: {
beforeCount: before.length,
afterCount: applied.length,
note: note ?? null,
},
});
return { applied: applied.length };
}
export async function createFundRequest(input: {
operationType: FundOperationType;
payload: Record<string, unknown>;
requestedBy: string;
/** Skip fund_operation.request check (e.g. user withdrawal). */
skipRequestPermission?: boolean;
/** Force queue even if policy says auto (unused reserved). */
forceQueue?: boolean;
}): Promise<FundRequestDto & { autoExecuted?: boolean }> {
if (!input.skipRequestPermission) {
const canRequest = await roleRepository.userHasPermission(
input.requestedBy,
'fund_operation.request'
);
if (!canRequest) throw new FundApprovalError('Permission denied: fund_operation.request');
}
const ctx = extractContext(input.operationType, input.payload);
const evaluated = await approvalPolicyEngine.evaluate({
operationType: input.operationType,
amountRaw: ctx.amountRaw,
walletTypeId: ctx.walletTypeId,
network: ctx.network,
sourceKind: ctx.sourceKind,
destKind: ctx.destKind,
});
const decision = evaluated.decision;
const meta = {
policyId: evaluated.policy?.id ?? null,
policySnapshot: decision as unknown as Record<string, unknown>,
requiredQuorum: decision.quorum,
amountRaw: ctx.amountRaw,
assetCode: ctx.assetCode,
network: ctx.network,
fromAddress: ctx.fromAddress,
toAddress: ctx.toAddress,
};
// Auto-execute path (never for policy changes)
if (
!input.forceQueue &&
decision.mode === 'auto_execute' &&
input.operationType !== 'approval_policy_change'
) {
let row: FundOperationRequestRow;
try {
row = await fundOperationRequestRepository.createRequest({
operationType: input.operationType,
payload: input.payload,
requestedBy: input.requestedBy,
meta,
});
} catch (e) {
const msg = e instanceof Error ? e.message : '';
if (/operation_type_check|violates check constraint/i.test(msg)) {
throw new FundApprovalError(
'Database schema is missing this operation type. Run db migrations and restart the backend.'
);
}
throw e;
}
await fundOperationRequestRepository.markApproved(row.id, input.requestedBy);
await fundOperationRequestRepository.markProcessing(row.id);
try {
const fresh = await fundOperationRequestRepository.findById(row.id);
const executionResult = await executeApprovedRequest(fresh!, input.requestedBy);
await fundOperationRequestRepository.markConfirmed(row.id, executionResult);
await auditLogRepository.create({
userId: input.requestedBy,
action: 'fund_operation_auto_executed',
resourceType: 'fund_operation_request',
resourceId: row.id,
metadata: {
operation_type: input.operationType,
policy_id: evaluated.policy?.id ?? null,
amount_raw: ctx.amountRaw,
network: ctx.network,
from_address: ctx.fromAddress,
to_address: ctx.toAddress,
execution_result: executionResult,
},
});
const final = await fundOperationRequestRepository.findById(row.id);
return { ...(await toDto(final!)), autoExecuted: true };
} catch (e) {
const msg = e instanceof Error ? e.message : 'Execution failed';
await fundOperationRequestRepository.markFailed(row.id, msg);
await auditLogRepository.create({
userId: input.requestedBy,
action: 'fund_operation_failed',
resourceType: 'fund_operation_request',
resourceId: row.id,
metadata: { error: msg, auto: true },
});
throw new FundApprovalError(msg);
}
}
let row: FundOperationRequestRow;
try {
row = await fundOperationRequestRepository.createRequest({
operationType: input.operationType,
payload: input.payload,
requestedBy: input.requestedBy,
meta,
});
} catch (e) {
const msg = e instanceof Error ? e.message : '';
if (/operation_type_check|violates check constraint/i.test(msg)) {
throw new FundApprovalError(
'Database schema is missing this operation type. Run db migrations and restart the backend.'
);
}
throw e;
}
await auditLogRepository.create({
userId: input.requestedBy,
action: 'fund_operation_requested',
resourceType: 'fund_operation_request',
resourceId: row.id,
metadata: {
operation_type: input.operationType,
policy_id: evaluated.policy?.id ?? null,
amount_raw: ctx.amountRaw,
asset_code: ctx.assetCode,
network: ctx.network,
from_address: ctx.fromAddress,
to_address: ctx.toAddress,
quorum: decision.quorum,
},
});
return toDto(row, input.requestedBy);
}
export async function castVote(
requestId: string,
approverId: string
voterId: string,
decision: 'approve' | 'reject',
reason?: string
): Promise<FundRequestDto> {
const canApprove = await roleRepository.userHasPermission(approverId, 'fund_operation.approve');
const canApprove = await roleRepository.userHasPermission(voterId, 'fund_operation.approve');
if (!canApprove) throw new FundApprovalError('Permission denied: fund_operation.approve');
const existing = await fundOperationRequestRepository.findById(requestId);
@ -203,26 +469,137 @@ export async function approveFundRequest(
throw new FundApprovalError(`Request is not pending (status: ${existing.status})`);
}
const approved = await fundOperationRequestRepository.markApproved(requestId, approverId);
if (!approved) throw new FundApprovalError('Failed to approve request');
const policyDecision = (existing.policy_snapshot as PolicyDecision | null) ?? {
mode: 'require_approvals' as const,
quorum: (existing.required_quorum as QuorumSlot[]) ?? [{ role: 'super_admin', count: 1 }],
forbid_self_approve: true,
};
const quorum = policyDecision.quorum ?? [];
if (policyDecision.forbid_self_approve !== false && voterId === existing.requested_by) {
throw new FundApprovalError('Self-approval is not allowed for this operation');
}
const prior = await fundOperationVoteRepository.findByRequestAndVoter(requestId, voterId);
if (prior) throw new FundApprovalError('You have already voted on this request');
const roles = await roleRepository.getUserRoleNames(voterId);
const perms = await roleRepository.getUserPermissions(voterId);
const annotated = approvalPolicyEngine.annotateVoterRolesForQuorum(roles, perms, quorum);
if (decision === 'approve') {
const approveVotes = (await fundOperationVoteRepository.listByRequest(requestId)).filter(
(v) => v.decision === 'approve'
);
if (!approvalPolicyEngine.voterFillsOpenSlot(quorum, approveVotes, roles, perms)) {
throw new FundApprovalError('Your role does not fill an open approval slot for this policy');
}
}
if (decision === 'reject') {
const trimmed = reason?.trim();
if (!trimmed) throw new FundApprovalError('Rejection reason is required');
await fundOperationVoteRepository.insertVote({
requestId,
voterId,
decision: 'reject',
reason: trimmed,
voterRoles: annotated,
});
const rejected = await fundOperationRequestRepository.markRejected(requestId, voterId, trimmed);
if (!rejected) throw new FundApprovalError('Failed to reject request');
if (existing.operation_type === 'user_withdrawal') {
const { transactionId } = existing.payload as { transactionId?: string };
if (transactionId) {
const { abandonPendingWithdrawal } = await import('./withdrawalService');
await abandonPendingWithdrawal(transactionId, trimmed);
}
}
await auditLogRepository.create({
userId: voterId,
action: 'fund_operation_rejected',
resourceType: 'fund_operation_request',
resourceId: requestId,
metadata: {
reason: trimmed,
operation_type: existing.operation_type,
amount_raw: existing.amount_raw,
network: existing.network,
from_address: existing.from_address,
to_address: existing.to_address,
},
});
return toDto(rejected, voterId);
}
await fundOperationVoteRepository.insertVote({
requestId,
voterId,
decision: 'approve',
reason: reason?.trim() || null,
voterRoles: annotated,
});
await fundOperationRequestRepository.touchApprovedBy(requestId, voterId);
const allVotes = await fundOperationVoteRepository.listByRequest(requestId);
const approveVotes = allVotes.filter((v) => v.decision === 'approve');
const complete = approvalPolicyEngine.isQuorumComplete(quorum, approveVotes);
await auditLogRepository.create({
userId: voterId,
action: 'fund_operation_vote_approved',
resourceType: 'fund_operation_request',
resourceId: requestId,
metadata: {
operation_type: existing.operation_type,
quorum_complete: complete,
progress: approvalPolicyEngine.countQuorumProgress(quorum, approveVotes),
},
});
if (!complete) {
const pending = await fundOperationRequestRepository.findById(requestId);
return toDto(pending!, voterId);
}
const approved = await fundOperationRequestRepository.markApproved(requestId, voterId);
if (!approved) {
// Race: already approved
const current = await fundOperationRequestRepository.findById(requestId);
return toDto(current!, voterId);
}
await fundOperationRequestRepository.markProcessing(requestId);
try {
const executionResult = await executeApprovedRequest(approved, approverId);
await fundOperationRequestRepository.markExecuted(requestId, executionResult);
const fresh = await fundOperationRequestRepository.findById(requestId);
const executionResult = await executeApprovedRequest(fresh!, voterId);
await fundOperationRequestRepository.markConfirmed(requestId, executionResult);
await auditLogRepository.create({
userId: approverId,
userId: voterId,
action: 'fund_operation_approved',
resourceType: 'fund_operation_request',
resourceId: requestId,
metadata: { operation_type: approved.operation_type, execution_result: executionResult },
metadata: {
operation_type: approved.operation_type,
execution_result: executionResult,
amount_raw: approved.amount_raw,
network: approved.network,
from_address: approved.from_address,
to_address: approved.to_address,
tx_hash:
(executionResult as { txHash?: string; blockchainTxId?: string }).txHash ??
(executionResult as { blockchainTxId?: string }).blockchainTxId ??
null,
},
});
const final = await fundOperationRequestRepository.findById(requestId);
return toDto(final!);
return toDto(final!, voterId);
} catch (e) {
const msg = e instanceof Error ? e.message : 'Execution failed';
await fundOperationRequestRepository.markFailed(requestId, msg);
await auditLogRepository.create({
userId: approverId,
userId: voterId,
action: 'fund_operation_failed',
resourceType: 'fund_operation_request',
resourceId: requestId,
@ -232,29 +609,19 @@ export async function approveFundRequest(
}
}
export async function approveFundRequest(
requestId: string,
approverId: string
): Promise<FundRequestDto> {
return castVote(requestId, approverId, 'approve');
}
export async function rejectFundRequest(
requestId: string,
approverId: string,
reason: string
): Promise<FundRequestDto> {
const canApprove = await roleRepository.userHasPermission(approverId, 'fund_operation.approve');
if (!canApprove) throw new FundApprovalError('Permission denied: fund_operation.approve');
const trimmed = reason?.trim();
if (!trimmed) throw new FundApprovalError('Rejection reason is required');
const rejected = await fundOperationRequestRepository.markRejected(requestId, approverId, trimmed);
if (!rejected) throw new FundApprovalError('Request not found or not pending');
await auditLogRepository.create({
userId: approverId,
action: 'fund_operation_rejected',
resourceType: 'fund_operation_request',
resourceId: requestId,
metadata: { reason: trimmed },
});
return toDto(rejected);
return castVote(requestId, approverId, 'reject', reason);
}
export async function cancelFundRequest(
@ -275,22 +642,99 @@ export async function cancelFundRequest(
const cancelled = await fundOperationRequestRepository.markCancelled(requestId);
if (!cancelled) throw new FundApprovalError('Failed to cancel request');
return toDto(cancelled);
if (existing.operation_type === 'user_withdrawal') {
const { transactionId } = existing.payload as { transactionId?: string };
if (transactionId) {
const { abandonPendingWithdrawal } = await import('./withdrawalService');
await abandonPendingWithdrawal(transactionId, 'cancelled');
}
}
await auditLogRepository.create({
userId: actorId,
action: 'fund_operation_cancelled',
resourceType: 'fund_operation_request',
resourceId: requestId,
metadata: { operation_type: existing.operation_type },
});
return toDto(cancelled, actorId);
}
export async function getFundRequest(requestId: string): Promise<FundRequestDto | null> {
export async function getFundRequest(
requestId: string,
viewerId?: string
): Promise<FundRequestDto | null> {
const row = await fundOperationRequestRepository.findById(requestId);
return row ? toDto(row) : null;
return row ? toDto(row, viewerId) : null;
}
export async function listFundRequests(filters: {
status?: FundOperationStatus;
operationType?: FundOperationType;
limit?: number;
offset?: number;
}): Promise<{ items: FundRequestDto[]; total: number }> {
export async function listFundRequests(
filters: {
status?: FundOperationStatus;
operationType?: FundOperationType;
limit?: number;
offset?: number;
},
viewerId?: string
): Promise<{ items: FundRequestDto[]; total: number }> {
const result = await fundOperationRequestRepository.listRequests(filters);
return { items: result.items.map(toDto), total: result.total };
const items = await Promise.all(result.items.map((r) => toDto(r, viewerId)));
return { items, total: result.total };
}
/** Submit a full policy set replacement via Approvals (does not apply immediately). */
export async function draftPolicyChange(input: {
after: PolicyInput[];
note?: string;
requestedBy: string;
}): Promise<FundRequestDto> {
const canManage = await roleRepository.userHasPermission(
input.requestedBy,
'approval_policy.manage'
);
const canManageGranular = await roleRepository.userHasPermission(
input.requestedBy,
'admin.approval_policies.manage'
);
if (!canManage && !canManageGranular) {
throw new FundApprovalError('Permission denied: approval_policy.manage');
}
if (!Array.isArray(input.after) || !input.after.length) {
throw new FundApprovalError('after must be a non-empty policies array');
}
const before = await approvalPolicyRepository.listAllPolicies();
return createFundRequest({
operationType: 'approval_policy_change',
payload: {
before,
after: input.after,
note: input.note,
},
requestedBy: input.requestedBy,
});
}
export async function listApprovalPolicies(actorId: string) {
const canView =
(await roleRepository.userHasPermission(actorId, 'approval_policy.view')) ||
(await roleRepository.userHasPermission(actorId, 'admin.approval_policies.view')) ||
(await roleRepository.userHasPermission(actorId, 'approval_policy.manage')) ||
(await roleRepository.userHasPermission(actorId, 'admin.approval_policies.manage')) ||
(await roleRepository.userHasRole(actorId, 'super_admin'));
if (!canView) throw new FundApprovalError('Permission denied: approval_policy.view');
await approvalPolicyRepository.ensureDefaultPoliciesSeeded();
return approvalPolicyRepository.listAllPolicies();
}
export async function listPolicyRevisions(actorId: string, limit?: number) {
const canView =
(await roleRepository.userHasPermission(actorId, 'approval_policy.view')) ||
(await roleRepository.userHasPermission(actorId, 'admin.approval_policies.view')) ||
(await roleRepository.userHasRole(actorId, 'super_admin'));
if (!canView) throw new FundApprovalError('Permission denied: approval_policy.view');
return approvalPolicyRepository.listRevisions(limit);
}
export type UserRoleName = RoleName;

View File

@ -334,6 +334,151 @@ export async function executeHotToColdGas(input: {
};
}
function hotUsdtMinReserveRaw(): bigint {
try {
return BigInt(config.treasury.hotUsdtMinReserveRaw || '0');
} catch {
return 0n;
}
}
/** Preview USDT (or network token) Hot → Cold: balances, gas, maxSendable after reserve. */
export async function previewHotToColdUsdt(walletTypeId: number) {
const wt = await walletRepository.getWalletTypeById(walletTypeId);
if (!wt) throw new Error('Unknown wallet type');
const cold = await coldWalletRepository.getActiveColdWallet(walletTypeId);
const hot = await hotWalletRepository.getActiveHotWallet(walletTypeId);
if (!cold) throw new Error('No active cold wallet for this network');
if (!hot) throw new Error('No active hot wallet for this network');
assertValidNativeRecipient(wt.network, cold.address);
let hotUsdt = 0n;
let hotNative = 0n;
let coldUsdt = 0n;
let nativeSymbol = 'BNB';
let nativeDecimals = 18;
let minNative = MIN_BNB_WEI_FOR_WITHDRAWAL;
let txBuffer = BSC_NATIVE_TX_BUFFER_WEI;
let tokenContract = '';
if (wt.network === 'BSC' || wt.code === USDT_BEP20_CODE) {
tokenContract = bscService.resolveUsdtContract(wt.contract_address);
hotUsdt = await bscService.getUsdtBalanceRaw(hot.address, tokenContract);
coldUsdt = await bscService.getUsdtBalanceRaw(cold.address, tokenContract);
hotNative = await bscService.getNativeBalanceWei(hot.address);
} else if (wt.network === 'TRON' || wt.code === USDT_TRC20_CODE) {
tokenContract =
config.blockchain.tron.usdtTrc20Contract || wt.contract_address || '';
if (!tokenContract) throw new Error('USDT TRC20 contract not configured');
hotUsdt = await tronService.getTrc20BalanceRaw(hot.address, tokenContract);
coldUsdt = await tronService.getTrc20BalanceRaw(cold.address, tokenContract);
hotNative = await tronService.getTrxBalanceSun(hot.address);
nativeSymbol = 'TRX';
nativeDecimals = 6;
minNative = MIN_TRX_SUN_FOR_WITHDRAWAL;
txBuffer = TRON_NATIVE_TX_BUFFER_SUN;
} else {
throw new Error('Hot→Cold USDT is only supported for BEP20 and TRC20');
}
const minUsdtReserve = hotUsdtMinReserveRaw();
const maxSendable = hotUsdt > minUsdtReserve ? hotUsdt - minUsdtReserve : 0n;
const gasOk = hotNative >= minNative + txBuffer;
return {
walletTypeId,
network: wt.network,
walletCode: wt.code,
tokenSymbol: 'USDT',
tokenDecimals: wt.decimals,
tokenContract,
fromHot: hot.address,
toCold: cold.address,
hotUsdt: hotUsdt.toString(),
coldUsdt: coldUsdt.toString(),
hotNative: hotNative.toString(),
nativeSymbol,
nativeDecimals,
minNativeForWithdraw: minNative.toString(),
txFeeBuffer: txBuffer.toString(),
minUsdtReserve: minUsdtReserve.toString(),
maxSendable: maxSendable.toString(),
gasOk,
gasHint: gasOk
? null
: `Hot wallet needs ≥ ${(minNative + txBuffer).toString()} ${nativeSymbol} (withdraw reserve + fee buffer) to broadcast`,
};
}
/** Platform-signed USDT Hot → Cold after Super Admin approval. */
export async function executeHotToColdUsdt(input: {
walletTypeId: number;
amountRaw: bigint;
notes?: string;
requestedBy: string;
approvedBy: string;
}) {
if (input.amountRaw <= 0n) throw new Error('Invalid USDT amount');
const preview = await previewHotToColdUsdt(input.walletTypeId);
if (!preview.gasOk) {
throw new Error(preview.gasHint || 'Hot wallet has insufficient native gas');
}
if (input.amountRaw > BigInt(preview.maxSendable)) {
throw new Error(
`Amount exceeds max sendable after USDT reserve. Max: ${preview.maxSendable}`
);
}
const hot = await hotWalletRepository.getActiveHotWallet(input.walletTypeId);
if (!hot) throw new Error('No active hot wallet');
const privateKey = decryptPrivateKey(hot.encrypted_private_key);
const row = await exchangeFundingRepository.createFunding({
walletTypeId: input.walletTypeId,
direction: 'hot_to_cold',
amount: input.amountRaw,
fromAddress: preview.fromHot,
toAddress: preview.toCold,
notes: input.notes,
requestedBy: input.requestedBy,
approvedBy: input.approvedBy,
});
let txId: string;
try {
if (preview.network === 'BSC' || preview.walletCode === USDT_BEP20_CODE) {
txId = await bscService.sendUsdt(
privateKey,
preview.tokenContract,
preview.toCold,
input.amountRaw
);
} else {
txId = await tronService.sendTrc20(
privateKey,
preview.tokenContract,
preview.toCold,
input.amountRaw
);
}
} catch (e) {
await exchangeFundingRepository.cancelFunding(row.id);
throw e;
}
await exchangeFundingRepository.completeFundingBroadcast(row.id, txId, input.approvedBy);
return {
fundingId: row.id,
blockchainTxId: txId,
from: preview.fromHot,
to: preview.toCold,
amount: input.amountRaw.toString(),
symbol: 'USDT',
network: preview.network,
message: 'Sent USDT from hot to cold',
};
}
export async function requestColdToHotGasFunding(
requestedBy: string,
input: {

View File

@ -115,6 +115,8 @@ export type WithdrawalResult = {
amount: string;
fee: string;
totalDebited: string;
fundRequestId?: string;
blockchainTxId?: string | null;
};
/**
@ -237,12 +239,140 @@ export async function requestWithdrawal(
},
});
const amountUsd = rawAmountToUsdApprox(USDT_TRC20_CODE, amountRaw, LEDGER_USDT_DECIMALS);
if (amountUsd >= settings.large_withdrawal_threshold_usd) {
await transactionRepository.updateStatus(tx.id, 'pending_approval');
const { createFundRequest } = await import('./fundApprovalService');
const fundReq = await createFundRequest({
operationType: 'user_withdrawal',
payload: {
transactionId: tx.id,
userId,
amountRaw: amountRaw.toString(),
feeRaw: feeRaw.toString(),
walletTypeId: railWalletType.id,
walletCode: walletTypeCode,
assetCode: walletTypeCode,
network,
fromAddress: hotWallet.address,
toAddress,
},
requestedBy: userId,
skipRequestPermission: true,
});
return {
transactionId: tx.id,
status: fundReq.autoExecuted ? 'completed' : 'pending_approval',
amount: amountRaw.toString(),
fee: feeRaw.toString(),
totalDebited: totalDebit.toString(),
fundRequestId: fundReq.id,
};
}
return broadcastWithdrawalTx({
txId: tx.id,
userId,
accountId: account.id,
totalDebit,
amountRaw,
feeRaw,
toAddress,
network,
walletTypeCode,
railWalletType,
hotWallet,
ledgerWalletTypeId: ledgerWalletType.id,
});
}
/** Resume on-chain broadcast after Approvals quorum for a large withdrawal. */
export async function broadcastApprovedWithdrawal(
transactionId: string,
approvedBy: string
): Promise<Record<string, unknown>> {
const tx = await transactionRepository.findById(transactionId);
if (!tx) throw new Error('Withdrawal transaction not found');
if (tx.status !== 'pending_approval' && tx.status !== 'pending') {
throw new Error(`Withdrawal is not awaiting approval (status: ${tx.status})`);
}
const meta = (tx.metadata ?? {}) as Record<string, unknown>;
const walletTypeCode = String(meta.rail_wallet_type || '');
const network = String(meta.network || '') as 'TRON' | 'BSC' | 'POLYGON';
const railWalletType = await walletRepository.getWalletTypeByCode(walletTypeCode);
if (!railWalletType) throw new Error('Unknown withdrawal rail');
const hotWallet = await hotWalletRepository.getActiveHotWallet(railWalletType.id);
if (!hotWallet) throw new Error('Withdrawal temporarily unavailable');
const ledgerWalletType = await walletRepository.getWalletTypeByCode(USDT_TRC20_CODE);
if (!ledgerWalletType) throw new Error('USDT ledger wallet type not configured');
const account = await ledgerRepository.getOrCreateAccount(tx.user_id, ledgerWalletType.id);
const amountRaw = BigInt(tx.amount);
const feeRaw = BigInt(tx.fee || '0');
const totalDebit = amountRaw + feeRaw;
const result = await broadcastWithdrawalTx({
txId: tx.id,
userId: tx.user_id,
accountId: account.id,
totalDebit,
amountRaw,
feeRaw,
toAddress: tx.to_address || '',
network: network === 'BSC' || network === 'POLYGON' ? network : 'TRON',
walletTypeCode,
railWalletType,
hotWallet,
ledgerWalletTypeId: ledgerWalletType.id,
});
await auditLogRepository.create({
userId: approvedBy,
action: 'withdrawal_approval_broadcast',
resourceType: 'transaction',
resourceId: tx.id,
metadata: { approvedBy, blockchainTxId: result.blockchainTxId ?? null },
});
return result;
}
async function broadcastWithdrawalTx(input: {
txId: string;
userId: string;
accountId: string;
totalDebit: bigint;
amountRaw: bigint;
feeRaw: bigint;
toAddress: string;
network: string;
walletTypeCode: string;
railWalletType: WalletType;
hotWallet: { address: string; encrypted_private_key: string };
ledgerWalletTypeId: number;
}): Promise<WithdrawalResult & { blockchainTxId?: string | null }> {
const {
txId,
userId,
accountId,
totalDebit,
amountRaw,
feeRaw,
toAddress,
network,
walletTypeCode,
railWalletType,
hotWallet,
ledgerWalletTypeId,
} = input;
let blockchainTxId: string | null = null;
try {
const privateKey = decryptPrivateKey(hotWallet.encrypted_private_key);
await transactionRepository.updateStatus(tx.id, 'broadcasting');
await transactionRepository.updateStatus(txId, 'broadcasting');
if (railWalletType.network === 'TRON') {
const trc20Contract =
@ -259,24 +389,24 @@ export async function requestWithdrawal(
throw new Error('Unsupported network');
}
await transactionRepository.updateStatus(tx.id, 'confirming', 0, blockchainTxId);
await transactionRepository.updateStatus(txId, 'confirming', 0, blockchainTxId);
try {
await ledgerRepository.finalizeWithdrawalFromLocked(account.id, totalDebit, tx.id);
await withdrawalLockRepository.deleteByTransactionId(tx.id);
await transactionRepository.updateStatus(tx.id, 'completed', 1);
await ledgerRepository.finalizeWithdrawalFromLocked(accountId, totalDebit, txId);
await withdrawalLockRepository.deleteByTransactionId(txId);
await transactionRepository.updateStatus(txId, 'completed', 1);
} catch (ledgerErr) {
await transactionRepository.updateStatus(tx.id, 'ledger_finalize_failed', 1, blockchainTxId);
await transactionRepository.updateStatus(txId, 'ledger_finalize_failed', 1, blockchainTxId);
await raiseAlert({
userId,
severity: 'critical',
alertType: 'withdrawal_ledger_finalize_failed',
title: 'Withdrawal broadcast succeeded but ledger finalization failed',
details:
`transaction=${tx.id}, blockchain_tx=${blockchainTxId}, amount=${amountRaw.toString()}, fee=${feeRaw.toString()}. ` +
`transaction=${txId}, blockchain_tx=${blockchainTxId}, amount=${amountRaw.toString()}, fee=${feeRaw.toString()}. ` +
`Funds remain locked; manual reconciliation required.`,
metadata: {
transactionId: tx.id,
transactionId: txId,
blockchainTxId,
amount: amountRaw.toString(),
fee: feeRaw.toString(),
@ -290,7 +420,7 @@ export async function requestWithdrawal(
userId,
action: 'withdrawal_completed',
resourceType: 'transaction',
resourceId: tx.id,
resourceId: txId,
metadata: {
amount: amountRaw.toString(),
fee: feeRaw.toString(),
@ -305,31 +435,32 @@ export async function requestWithdrawal(
try {
await referralService.processWithdrawalReferralCommissions({
userId,
withdrawalTransactionId: tx.id,
withdrawalTransactionId: txId,
withdrawalAmount: amountRaw,
walletTypeId: ledgerWalletType.id,
walletTypeId: ledgerWalletTypeId,
});
} catch (referralErr) {
console.error('[referral] Withdrawal commission processing failed:', referralErr);
}
return {
transactionId: tx.id,
transactionId: txId,
status: 'completed',
amount: amountRaw.toString(),
fee: feeRaw.toString(),
totalDebited: totalDebit.toString(),
blockchainTxId,
};
} catch (err) {
if (!blockchainTxId) {
await ledgerRepository.unlockBalance(account.id, totalDebit);
await withdrawalLockRepository.deleteByTransactionId(tx.id);
await transactionRepository.updateStatus(tx.id, 'failed');
await ledgerRepository.unlockBalance(accountId, totalDebit);
await withdrawalLockRepository.deleteByTransactionId(txId);
await transactionRepository.updateStatus(txId, 'failed');
await auditLogRepository.create({
userId,
action: 'withdrawal_failed',
resourceType: 'transaction',
resourceId: tx.id,
resourceId: txId,
metadata: { error: String(err) },
});
queueUserAdminStatsRefresh(userId);
@ -339,4 +470,28 @@ export async function requestWithdrawal(
}
}
export { SecurityBlockedError };
/** Unlock ledger and fail tx when a large-withdrawal approval is rejected/cancelled. */
export async function abandonPendingWithdrawal(transactionId: string, reason: string): Promise<void> {
const tx = await transactionRepository.findById(transactionId);
if (!tx) return;
if (tx.status !== 'pending_approval' && tx.status !== 'pending') return;
const ledgerWalletType = await walletRepository.getWalletTypeByCode(USDT_TRC20_CODE);
if (!ledgerWalletType) return;
const account = await ledgerRepository.getOrCreateAccount(tx.user_id, ledgerWalletType.id);
const amountRaw = BigInt(tx.amount);
const feeRaw = BigInt(tx.fee || '0');
const totalDebit = amountRaw + feeRaw;
await ledgerRepository.unlockBalance(account.id, totalDebit);
await withdrawalLockRepository.deleteByTransactionId(tx.id);
await transactionRepository.updateStatus(tx.id, 'failed');
await auditLogRepository.create({
userId: tx.user_id,
action: 'withdrawal_approval_abandoned',
resourceType: 'transaction',
resourceId: tx.id,
metadata: { reason },
});
queueUserAdminStatsRefresh(tx.user_id);
}

View File

@ -94,15 +94,50 @@ export const fundRequestCreateBodySchema = z.object({
operationType: z.enum([
'ledger_credit',
'treasury_cold_to_hot',
'treasury_hot_to_cold',
'bonus_pool_fund',
'sweep_manual',
'sweep_batch',
'treasury_hot_to_cold_gas',
'treasury_cold_to_hot_gas',
'user_withdrawal',
'approval_policy_change',
]),
payload: z.record(z.string(), z.unknown()),
});
const quorumSlotSchema = z.object({
role: z.string().trim().min(1).max(64).optional(),
permission: z.string().trim().min(1).max(128).optional(),
count: z.number().int().min(1).max(20),
});
const policyDecisionSchema = z.object({
mode: z.enum(['auto_execute', 'require_approvals']),
quorum: z.array(quorumSlotSchema).max(20),
forbid_self_approve: z.boolean().optional(),
require_distinct_users: z.boolean().optional(),
});
export const approvalPolicyItemSchema = z.object({
name: z.string().trim().min(1).max(128),
enabled: z.boolean().optional(),
priority: z.number().int().min(0).max(1_000_000).optional(),
operationType: z.string().trim().max(64).nullable().optional(),
walletTypeId: z.number().int().positive().nullable().optional(),
network: z.string().trim().max(32).nullable().optional(),
amountMinRaw: z.string().trim().max(78).nullable().optional(),
amountMaxRaw: z.string().trim().max(78).nullable().optional(),
sourceWalletKind: z.enum(['hot', 'cold', 'hd', 'user', 'any']).optional(),
destWalletKind: z.enum(['hot', 'cold', 'hd', 'user', 'any']).optional(),
decision: policyDecisionSchema,
});
export const approvalPolicyDraftBodySchema = z.object({
after: z.array(approvalPolicyItemSchema).min(1).max(200),
note: z.string().trim().max(2000).optional(),
});
export const fundRequestRejectBodySchema = z.object({
reason: z.string().trim().min(1).max(2000),
});

View File

@ -66,6 +66,8 @@ x-backend-common: &backend-common
SWEEP_POLL_INTERVAL_MS: ${SWEEP_POLL_INTERVAL_MS:-120000}
SWEEP_BSC_GAS_TOPUP_WEI: ${SWEEP_BSC_GAS_TOPUP_WEI:-1000000000000000}
SWEEP_TRON_GAS_TOPUP_SUN: ${SWEEP_TRON_GAS_TOPUP_SUN:-15000000}
# Optional USDT floor left on hot after Hot→Cold (raw chain units; 0 = no fixed USDT reserve)
HOT_USDT_MIN_RESERVE_RAW: ${HOT_USDT_MIN_RESERVE_RAW:-0}
RATE_LIMIT_MAX: ${RATE_LIMIT_MAX:-2000}
INITIAL_SETUP_TOKEN: ${INITIAL_SETUP_TOKEN:-}
# Emergency Super Admin 2FA reset CLI only (not an HTTP API). Min 32 chars; leave empty to disable break-glass.

View File

@ -84,6 +84,8 @@ nano .env # ou vim
| `SWEEP_AUTO_EXECUTE` | `false` (défaut) = Submit + Approvals ; `true` = sweep HD→cold automatique après contrôles |
| `SWEEP_AUTO_MAX_AMOUNT_RAW` | Optionnel — au-dessus de ce montant (raw), l’approbation manuelle reste obligatoire |
| `SWEEP_COLD_ALLOWLIST` | Optionnel mais **recommandé** avec auto : adresses cold autorisées (séparées par virgule) |
| `HOT_USDT_MIN_RESERVE_RAW` | Optionnel — plancher USDT laissé sur le hot après Hot→Cold (raw ; `0` = pas de réserve fixe) |
| Approbations (DB) | Règles N-sur-M dans **Options → Règles d’approbation** (pas d’env). Seed défaut = 1 Super Admin + anti auto-approbation. `SWEEP_AUTO_*` reste un fallback / kill-switch pour les sweeps. |
| `APP_PUBLIC_URL` | Ex. HTTP test : `http://prediqo.redirectme.net:9080` · HTTPS : `https://…:9443` |
| `CORS_ORIGINS` | Même origine que le front (schéma + hôte + port) |
| `VITE_API_BASE_URL` | Même URL de base que `APP_PUBLIC_URL` (sans `/api`) — **rebuild** front après changement |
@ -496,11 +498,35 @@ Le transfert on-chain est **manuel** (clé cold hors plateforme) ; Prediqo enreg
> **Important :** le cold doit être une adresse **externe** (MetaMask / hardware), **pas** une adresse Receive d’un user Prediqo (HD). Sinon vous ne pourrez pas signer le Cold → Hot.
1. Treasury → **Cold → Hot funding** : réseau **USDT (BEP20)**, montant en **USDT** (ex. `2`) → **Request funding** → Approvals.
1. Treasury → **Hot ↔ Cold USDT** : route **Cold → Hot**, réseau **USDT (BEP20)**, montant en **USDT** (ex. `2`) → **Request funding** → Approvals.
2. Après approbation : transferrer manuellement USDT BEP20 **cold → hot** (adresse hot affichée / Copier).
3. Treasury → **Confirm tx** avec le hash BscScan.
4. Vérifier le solde USDT hot on-chain (Treasury / explorateur).
#### B2. Hot → Cold USDT (excédent hot → cold)
Après Approvals, la **plateforme** signe depuis le hot (pas MetaMask). Destination = cold **actif** en base uniquement.
1. Treasury → **Hot ↔ Cold USDT** : route **Hot → Cold**, réseau, montant (ou **Max**) → **Request hot → cold**.
2. Approvals → Super Admin approuve `treasury_hot_to_cold` → broadcast on-chain automatique.
3. Contrôles : solde USDT hot, gas natif ≥ min retrait, plancher optionnel `HOT_USDT_MIN_RESERVE_RAW` (défaut `0` = pas de réserve USDT fixe ; max envoyable = solde − réserve).
```bash
# Exemple .env / docker-compose (défaut)
HOT_USDT_MIN_RESERVE_RAW=0
# Ex. BEP20 : garder ~10 USDT sur le hot → 10000000000000000000
```
Différence vs gas Hot→Cold : ici c’est de l’**USDT** ; le gas Hot→Cold reste la carte « Gas transfer » (BNB / TRX).
### Règles d’approbation (N-sur-M)
Après migration DB, les tables `approval_policies` / `fund_operation_votes` sont créées et seedées (1× Super Admin, `forbid_self_approve`).
- **UI** : Options → **Règles d’approbation** (`/admin/approval-policies`). Les changements passent par Approvals (`approval_policy_change`) — pas de save silencieux.
- **Retraits** : au-dessus de `large_withdrawal_threshold_usd` (Settings) → file Approvals `user_withdrawal` ; en dessous → broadcast immédiat (comportement historique).
- **Sweeps** : `SWEEP_AUTO_EXECUTE` / `SWEEP_AUTO_MAX_AMOUNT_RAW` continuent de fonctionner. Vous pouvez aussi ajouter une policy DB `sweep_batch` en `auto_execute` avec `amount_max_raw` ; la policy DB s’applique aux demandes créées via `createFundRequest`.
##### Récupérer des USDT bloqués sur une « fausse » cold (adresse HD user)
Si une adresse Receive Prediqo a été enregistrée comme cold par erreur :

View File

@ -650,7 +650,7 @@ code + .copy-button {
<script type="text/javascript">
function configurationCacheProblems() { return (
// begin-report-data
{"diagnostics":[{"problem":[{"text":"Executing Gradle on JVM versions 16 and lower has been deprecated."}],"severity":"WARNING","problemDetails":[{"text":"This will fail with an error in Gradle 9.0."}],"contextualLabel":"Executing Gradle on JVM versions 16 and lower has been deprecated.","documentationLink":"https://docs.gradle.org/8.12/userguide/upgrading_version_8.html#minimum_daemon_jvm_version","problemId":[{"name":"deprecation","displayName":"Deprecation"},{"name":"executing-gradle-on-jvm-versions-and-lower","displayName":"Executing Gradle on JVM versions 16 and lower has been deprecated."}],"solutions":[[{"text":"Use JVM 17 or greater to execute Gradle. Projects can continue to use older JVM versions via toolchains."}]]},{"problem":[{"text":"No variants exist that would match the request"}],"severity":"ERROR","contextualLabel":"Dependency requires at least JVM runtime version 11. This build uses a Java 8 JVM.","documentationLink":"https://docs.gradle.org/8.12/userguide/variant_model.html#sec:variant-select-errors","problemId":[{"name":"dependency-variant-resolution","displayName":"Variant resolution"},{"name":"no-compatible-variants","displayName":"No variants exist that would match the request"}]}],"problemsReport":{"totalProblemCount":2,"requestedTasks":"","documentationLink":"https://docs.gradle.org/8.12/userguide/problems-report.html","documentationLinkCaption":"Problem report","summaries":[]}}
{"diagnostics":[{"problem":[{"text":"Executing Gradle on JVM versions 16 and lower has been deprecated."}],"severity":"WARNING","problemDetails":[{"text":"This will fail with an error in Gradle 9.0."}],"contextualLabel":"Executing Gradle on JVM versions 16 and lower has been deprecated.","documentationLink":"https://docs.gradle.org/8.12/userguide/upgrading_version_8.html#minimum_daemon_jvm_version","problemId":[{"name":"deprecation","displayName":"Deprecation"},{"name":"executing-gradle-on-jvm-versions-and-lower","displayName":"Executing Gradle on JVM versions 16 and lower has been deprecated."}],"solutions":[[{"text":"Use JVM 17 or greater to execute Gradle. Projects can continue to use older JVM versions via toolchains."}]]}],"problemsReport":{"totalProblemCount":1,"requestedTasks":"","documentationLink":"https://docs.gradle.org/8.12/userguide/problems-report.html","documentationLinkCaption":"Problem report","summaries":[]}}
// end-report-data
);}
</script>

View File

@ -22,6 +22,7 @@ import { HomePage } from '../../features/home/HomePage';
import { CatalogAdminPage } from '../../features/catalog/CatalogAdminPage';
import { TreasuryAdminPage } from '../../features/treasury/TreasuryAdminPage';
import { ApprovalsPage } from '../../features/approvals/ApprovalsPage';
import { ApprovalPoliciesPage } from '../../features/approvals/ApprovalPoliciesPage';
import { ReferralAdminPage } from '../../features/referral/ReferralAdminPage';
import { ReferralPage } from '../../features/referral/ReferralPage';
import { ReferralFraudDashboardPage } from '../../features/referral/ReferralFraudDashboardPage';
@ -109,6 +110,7 @@ export const router = createBrowserRouter([
{ path: 'admin/catalog', element: <CatalogAdminPage /> },
{ path: 'admin/treasury', element: <TreasuryAdminPage /> },
{ path: 'admin/approvals', element: <ApprovalsPage /> },
{ path: 'admin/approval-policies', element: <ApprovalPoliciesPage /> },
{ path: 'admin/security', element: <SecurityAdminPage /> },
{ path: 'admin/referral', element: <ReferralAdminPage /> },
{ path: 'admin/referral/fraud', element: <ReferralFraudDashboardPage /> },

View File

@ -0,0 +1,525 @@
/**
* Admin UI for configurable approval policies (N-of-M).
* Changes are submitted to Approvals — never applied silently.
*/
import {
Alert,
Box,
Button,
Card,
CardContent,
Chip,
FormControl,
FormControlLabel,
InputLabel,
MenuItem,
Select,
Stack,
Switch,
Table,
TableBody,
TableCell,
TableHead,
TableRow,
TextField,
Typography,
} from '@mui/material';
import RuleFolderRoundedIcon from '@mui/icons-material/RuleFolderRounded';
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
import { useEffect, useState } from 'react';
import { useTranslation } from 'react-i18next';
import { api } from '../../shared/services/api';
import { PageHeader, RefreshIconButton } from '../../shared/components/PageHeader';
import { useAuth } from '../../shared/auth/AuthContext';
import { hasPermission } from '../../shared/auth/permissions';
import { ScrollableTable } from '../../shared/components/ScrollableTable';
import { apiErrorMessage } from '../../shared/utils/apiError';
type QuorumSlot = { role?: string; permission?: string; count: number };
type PolicyDecision = {
mode: 'auto_execute' | 'require_approvals';
quorum: QuorumSlot[];
forbid_self_approve: boolean;
require_distinct_users?: boolean;
};
type Policy = {
id?: string;
name: string;
enabled: boolean;
priority: number;
operation_type: string | null;
wallet_type_id: number | null;
network: string | null;
amount_min_raw: string | null;
amount_max_raw: string | null;
source_wallet_kind: string;
dest_wallet_kind: string;
decision: PolicyDecision;
};
type PolicyDraft = {
name: string;
enabled: boolean;
priority: number;
operationType: string | null;
walletTypeId: number | null;
network: string | null;
amountMinRaw: string | null;
amountMaxRaw: string | null;
sourceWalletKind: string;
destWalletKind: string;
decision: PolicyDecision;
};
const OP_TYPES = [
'',
'ledger_credit',
'treasury_cold_to_hot',
'treasury_hot_to_cold',
'treasury_hot_to_cold_gas',
'treasury_cold_to_hot_gas',
'sweep_batch',
'sweep_manual',
'bonus_pool_fund',
'user_withdrawal',
'approval_policy_change',
];
function toDraft(p: Policy): PolicyDraft {
return {
name: p.name,
enabled: p.enabled,
priority: p.priority,
operationType: p.operation_type,
walletTypeId: p.wallet_type_id,
network: p.network,
amountMinRaw: p.amount_min_raw,
amountMaxRaw: p.amount_max_raw,
sourceWalletKind: p.source_wallet_kind || 'any',
destWalletKind: p.dest_wallet_kind || 'any',
decision: {
mode: p.decision?.mode === 'auto_execute' ? 'auto_execute' : 'require_approvals',
quorum: p.decision?.quorum?.length
? p.decision.quorum.map((s) => ({ ...s, count: s.count || 1 }))
: [{ role: 'super_admin', count: 1 }],
forbid_self_approve: p.decision?.forbid_self_approve !== false,
require_distinct_users: p.decision?.require_distinct_users !== false,
},
};
}
const emptyPolicy = (): PolicyDraft => ({
name: 'New policy',
enabled: true,
priority: 100,
operationType: null,
walletTypeId: null,
network: null,
amountMinRaw: null,
amountMaxRaw: null,
sourceWalletKind: 'any',
destWalletKind: 'any',
decision: {
mode: 'require_approvals',
quorum: [{ role: 'super_admin', count: 1 }],
forbid_self_approve: true,
require_distinct_users: true,
},
});
export function ApprovalPoliciesPage() {
const { t } = useTranslation();
const qc = useQueryClient();
const { permissions } = useAuth();
const canView =
hasPermission(permissions, 'approval_policy.view') ||
hasPermission(permissions, 'admin.approval_policies.view') ||
hasPermission(permissions, 'approval_policy.manage') ||
hasPermission(permissions, 'admin.approval_policies.manage');
const canManage =
hasPermission(permissions, 'approval_policy.manage') ||
hasPermission(permissions, 'admin.approval_policies.manage');
const [drafts, setDrafts] = useState<PolicyDraft[]>([]);
const [note, setNote] = useState('');
const [message, setMessage] = useState<string | null>(null);
const [error, setError] = useState<string | null>(null);
const listQ = useQuery({
queryKey: ['admin-approval-policies'],
queryFn: async () => {
const res = await api.get<{ items: Policy[] }>('/api/v1/admin/approval-policies');
return res.data.items;
},
enabled: canView,
});
const revisionsQ = useQuery({
queryKey: ['admin-approval-policy-revisions'],
queryFn: async () => {
const res = await api.get<{
items: Array<{ id: string; created_at: string; note: string | null; actor_id: string | null }>;
}>('/api/v1/admin/approval-policies/revisions');
return res.data.items;
},
enabled: canView,
});
useEffect(() => {
if (listQ.data) setDrafts(listQ.data.map(toDraft));
}, [listQ.data]);
const submitMut = useMutation({
mutationFn: () =>
api.post('/api/v1/admin/approval-policies/draft-change', {
after: drafts,
note: note || undefined,
}),
onSuccess: () => {
setMessage(t('admin.approvalPolicies.submitted'));
setError(null);
setNote('');
void qc.invalidateQueries({ queryKey: ['admin-fund-requests'] });
},
onError: (err) => setError(apiErrorMessage(err, t('admin.approvalPolicies.submitFailed'))),
});
if (!canView) {
return <Alert severity="warning">{t('admin.approvalPolicies.noPermission')}</Alert>;
}
return (
<Box sx={{ minWidth: 0 }}>
<PageHeader
icon={<RuleFolderRoundedIcon color="primary" sx={{ fontSize: 36 }} />}
title={t('admin.approvalPolicies.title')}
subtitle={t('admin.approvalPolicies.subtitle')}
actions={
<RefreshIconButton
label={t('admin.approvalPolicies.refresh')}
onClick={() => void listQ.refetch()}
/>
}
/>
{message && (
<Alert severity="success" onClose={() => setMessage(null)} sx={{ mb: 2 }}>
{message}
</Alert>
)}
{error && (
<Alert severity="error" onClose={() => setError(null)} sx={{ mb: 2 }}>
{error}
</Alert>
)}
<Alert severity="info" sx={{ mb: 2 }}>
{t('admin.approvalPolicies.submitHint')}
</Alert>
<Stack spacing={2}>
{drafts.map((p, idx) => (
<Card key={idx} variant="outlined" sx={{ borderRadius: 2 }}>
<CardContent>
<Stack spacing={1.5}>
<Stack direction={{ xs: 'column', sm: 'row' }} spacing={1.25} useFlexGap flexWrap="wrap">
<TextField
size="small"
label={t('admin.approvalPolicies.name')}
value={p.name}
disabled={!canManage}
onChange={(e) => {
const next = [...drafts];
next[idx] = { ...p, name: e.target.value };
setDrafts(next);
}}
sx={{ minWidth: 220, flex: 1 }}
/>
<TextField
size="small"
type="number"
label={t('admin.approvalPolicies.priority')}
value={p.priority}
disabled={!canManage}
onChange={(e) => {
const next = [...drafts];
next[idx] = { ...p, priority: Number(e.target.value) || 0 };
setDrafts(next);
}}
sx={{ width: 120 }}
/>
<FormControl size="small" sx={{ minWidth: 200 }}>
<InputLabel>{t('admin.approvalPolicies.operationType')}</InputLabel>
<Select
label={t('admin.approvalPolicies.operationType')}
value={p.operationType ?? ''}
disabled={!canManage}
onChange={(e) => {
const next = [...drafts];
next[idx] = {
...p,
operationType: e.target.value ? e.target.value : null,
};
setDrafts(next);
}}
>
<MenuItem value="">{t('admin.approvalPolicies.anyOp')}</MenuItem>
{OP_TYPES.filter(Boolean).map((op) => (
<MenuItem key={op} value={op}>
{op}
</MenuItem>
))}
</Select>
</FormControl>
<FormControl size="small" sx={{ minWidth: 180 }}>
<InputLabel>{t('admin.approvalPolicies.mode')}</InputLabel>
<Select
label={t('admin.approvalPolicies.mode')}
value={p.decision.mode}
disabled={!canManage}
onChange={(e) => {
const next = [...drafts];
next[idx] = {
...p,
decision: {
...p.decision,
mode: e.target.value as PolicyDecision['mode'],
},
};
setDrafts(next);
}}
>
<MenuItem value="require_approvals">
{t('admin.approvalPolicies.modeRequire')}
</MenuItem>
<MenuItem value="auto_execute">{t('admin.approvalPolicies.modeAuto')}</MenuItem>
</Select>
</FormControl>
<FormControlLabel
control={
<Switch
checked={p.enabled}
disabled={!canManage}
onChange={(e) => {
const next = [...drafts];
next[idx] = { ...p, enabled: e.target.checked };
setDrafts(next);
}}
/>
}
label={t('admin.approvalPolicies.enabled')}
/>
</Stack>
<Stack direction={{ xs: 'column', sm: 'row' }} spacing={1.25} useFlexGap flexWrap="wrap">
<TextField
size="small"
label={t('admin.approvalPolicies.amountMin')}
value={p.amountMinRaw ?? ''}
disabled={!canManage}
onChange={(e) => {
const next = [...drafts];
next[idx] = { ...p, amountMinRaw: e.target.value || null };
setDrafts(next);
}}
sx={{ width: 180 }}
/>
<TextField
size="small"
label={t('admin.approvalPolicies.amountMax')}
value={p.amountMaxRaw ?? ''}
disabled={!canManage}
onChange={(e) => {
const next = [...drafts];
next[idx] = { ...p, amountMaxRaw: e.target.value || null };
setDrafts(next);
}}
sx={{ width: 180 }}
/>
<TextField
size="small"
label={t('admin.approvalPolicies.network')}
value={p.network ?? ''}
disabled={!canManage}
onChange={(e) => {
const next = [...drafts];
next[idx] = { ...p, network: e.target.value || null };
setDrafts(next);
}}
placeholder="BSC / TRON"
sx={{ width: 140 }}
/>
<FormControlLabel
control={
<Switch
checked={p.decision.forbid_self_approve}
disabled={!canManage}
onChange={(e) => {
const next = [...drafts];
next[idx] = {
...p,
decision: { ...p.decision, forbid_self_approve: e.target.checked },
};
setDrafts(next);
}}
/>
}
label={t('admin.approvalPolicies.forbidSelf')}
/>
</Stack>
<Typography variant="caption" sx={{ opacity: 0.7 }}>
{t('admin.approvalPolicies.quorumHint')}
</Typography>
<Stack direction="row" spacing={1} useFlexGap flexWrap="wrap" alignItems="center">
{p.decision.quorum.map((slot, sIdx) => (
<Stack key={sIdx} direction="row" spacing={0.75} alignItems="center">
<TextField
size="small"
label={t('admin.approvalPolicies.role')}
value={slot.role ?? ''}
disabled={!canManage}
onChange={(e) => {
const next = [...drafts];
const quorum = [...p.decision.quorum];
quorum[sIdx] = { ...slot, role: e.target.value || undefined };
next[idx] = { ...p, decision: { ...p.decision, quorum } };
setDrafts(next);
}}
sx={{ width: 140 }}
/>
<TextField
size="small"
type="number"
label={t('admin.approvalPolicies.count')}
value={slot.count}
disabled={!canManage}
onChange={(e) => {
const next = [...drafts];
const quorum = [...p.decision.quorum];
quorum[sIdx] = { ...slot, count: Math.max(1, Number(e.target.value) || 1) };
next[idx] = { ...p, decision: { ...p.decision, quorum } };
setDrafts(next);
}}
sx={{ width: 90 }}
/>
{canManage && (
<Button
size="small"
color="inherit"
onClick={() => {
const next = [...drafts];
const quorum = p.decision.quorum.filter((_, i) => i !== sIdx);
next[idx] = {
...p,
decision: {
...p.decision,
quorum: quorum.length ? quorum : [{ role: 'super_admin', count: 1 }],
},
};
setDrafts(next);
}}
>
×
</Button>
)}
</Stack>
))}
{canManage && (
<Button
size="small"
onClick={() => {
const next = [...drafts];
next[idx] = {
...p,
decision: {
...p.decision,
quorum: [...p.decision.quorum, { role: 'admin', count: 1 }],
},
};
setDrafts(next);
}}
>
{t('admin.approvalPolicies.addSlot')}
</Button>
)}
</Stack>
{canManage && (
<Button
size="small"
color="error"
onClick={() => setDrafts(drafts.filter((_, i) => i !== idx))}
>
{t('admin.approvalPolicies.removePolicy')}
</Button>
)}
</Stack>
</CardContent>
</Card>
))}
</Stack>
{canManage && (
<Stack direction={{ xs: 'column', sm: 'row' }} spacing={1.25} sx={{ mt: 2 }} alignItems="flex-start">
<Button variant="outlined" onClick={() => setDrafts([...drafts, emptyPolicy()])}>
{t('admin.approvalPolicies.addPolicy')}
</Button>
<TextField
size="small"
label={t('admin.approvalPolicies.note')}
value={note}
onChange={(e) => setNote(e.target.value)}
sx={{ minWidth: 260, flex: 1 }}
/>
<Button
variant="contained"
disabled={submitMut.isPending || drafts.length === 0}
onClick={() => void submitMut.mutateAsync()}
>
{t('admin.approvalPolicies.submitChange')}
</Button>
</Stack>
)}
<Typography variant="h6" sx={{ mt: 4, mb: 1, fontWeight: 800 }}>
{t('admin.approvalPolicies.history')}
</Typography>
<ScrollableTable minWidth={640}>
<Table size="small">
<TableHead>
<TableRow>
<TableCell>{t('admin.approvalPolicies.when')}</TableCell>
<TableCell>{t('admin.approvalPolicies.actor')}</TableCell>
<TableCell>{t('admin.approvalPolicies.note')}</TableCell>
</TableRow>
</TableHead>
<TableBody>
{(revisionsQ.data ?? []).length === 0 ? (
<TableRow>
<TableCell colSpan={3}>
<Typography variant="body2" sx={{ opacity: 0.6 }}>
{t('admin.approvalPolicies.noHistory')}
</Typography>
</TableCell>
</TableRow>
) : (
(revisionsQ.data ?? []).map((r) => (
<TableRow key={r.id}>
<TableCell>{new Date(r.created_at).toLocaleString()}</TableCell>
<TableCell sx={{ fontFamily: 'monospace', fontSize: 12 }}>
{r.actor_id ? `${r.actor_id.slice(0, 8)}…` : '—'}
</TableCell>
<TableCell>
{r.note || '—'} <Chip size="small" label={r.id.slice(0, 8)} sx={{ ml: 1 }} />
</TableCell>
</TableRow>
))
)}
</TableBody>
</Table>
</ScrollableTable>
</Box>
);
}

View File

@ -1,5 +1,5 @@
/**
* Super-admin inbox for pending fund operation approvals.
* Super-admin inbox for pending fund operation approvals (N-of-M).
*/
import {
Alert,
@ -27,6 +27,7 @@ import { api } from '../../shared/services/api';
import { PageHeader, RefreshIconButton } from '../../shared/components/PageHeader';
import { useAuth } from '../../shared/auth/AuthContext';
import { ScrollableTable } from '../../shared/components/ScrollableTable';
import { apiErrorMessage } from '../../shared/utils/apiError';
type FundRequest = {
id: string;
@ -37,18 +38,40 @@ type FundRequest = {
approvedBy: string | null;
rejectionReason: string | null;
createdAt: string;
policyName: string | null;
amountRaw: string | null;
assetCode: string | null;
network: string | null;
fromAddress: string | null;
toAddress: string | null;
quorumProgress: { required: number; approved: number };
canVote: boolean;
forbidSelfApprove: boolean;
votes: Array<{ voterId: string; decision: string; createdAt: string }>;
};
const OP_TYPE_KEYS = [
'ledger_credit',
'treasury_cold_to_hot',
'treasury_hot_to_cold',
'bonus_pool_fund',
'sweep_manual',
'sweep_batch',
'treasury_hot_to_cold_gas',
'treasury_cold_to_hot_gas',
'user_withdrawal',
'approval_policy_change',
] as const;
function shortId(id: string) {
return id.length > 10 ? `${id.slice(0, 8)}…` : id;
}
function shortAddr(a: string | null) {
if (!a) return '—';
return a.length > 14 ? `${a.slice(0, 8)}…${a.slice(-4)}` : a;
}
export function ApprovalsPage() {
const { t } = useTranslation();
const qc = useQueryClient();
@ -56,6 +79,7 @@ export function ApprovalsPage() {
const [rejectId, setRejectId] = useState<string | null>(null);
const [rejectReason, setRejectReason] = useState('');
const [message, setMessage] = useState<string | null>(null);
const [error, setError] = useState<string | null>(null);
const listQ = useQuery({
queryKey: ['admin-fund-requests'],
@ -72,8 +96,10 @@ export function ApprovalsPage() {
mutationFn: (id: string) => api.post(`/api/v1/admin/fund-requests/${id}/approve`),
onSuccess: () => {
setMessage(t('admin.approvals.approved'));
setError(null);
void qc.invalidateQueries({ queryKey: ['admin-fund-requests'] });
},
onError: (err) => setError(apiErrorMessage(err, t('admin.approvals.approveFailed'))),
});
const rejectMut = useMutation({
@ -83,8 +109,10 @@ export function ApprovalsPage() {
setRejectId(null);
setRejectReason('');
setMessage(t('admin.approvals.rejected'));
setError(null);
void qc.invalidateQueries({ queryKey: ['admin-fund-requests'] });
},
onError: (err) => setError(apiErrorMessage(err, t('admin.approvals.rejectFailed'))),
});
const opLabel = (operationType: string) => {
@ -116,6 +144,11 @@ export function ApprovalsPage() {
{message}
</Alert>
)}
{error && (
<Alert severity="error" onClose={() => setError(null)} sx={{ mb: 2 }}>
{error}
</Alert>
)}
{listQ.isError && (
<Alert severity="error" sx={{ mb: 2 }}>
@ -123,11 +156,13 @@ export function ApprovalsPage() {
</Alert>
)}
<ScrollableTable minWidth={720}>
<ScrollableTable minWidth={980}>
<Table size="small">
<TableHead>
<TableRow>
<TableCell>{t('admin.approvals.type')}</TableCell>
<TableCell>{t('admin.approvals.details')}</TableCell>
<TableCell>{t('admin.approvals.quorum')}</TableCell>
<TableCell>{t('admin.approvals.requestedBy')}</TableCell>
<TableCell>{t('admin.approvals.created')}</TableCell>
<TableCell>{t('common.status')}</TableCell>
@ -137,7 +172,7 @@ export function ApprovalsPage() {
<TableBody>
{items.length === 0 ? (
<TableRow>
<TableCell colSpan={5}>
<TableCell colSpan={7}>
<Typography variant="body2" sx={{ opacity: 0.6 }}>
{t('admin.approvals.noPending')}
</Typography>
@ -146,9 +181,40 @@ export function ApprovalsPage() {
) : (
items.map((r) => (
<TableRow key={r.id}>
<TableCell>{opLabel(r.operationType)}</TableCell>
<TableCell>
<Stack spacing={0.5}>
<Typography variant="body2" sx={{ fontWeight: 700 }}>
{opLabel(r.operationType)}
</Typography>
{r.policyName && (
<Typography variant="caption" sx={{ opacity: 0.65 }}>
{r.policyName}
</Typography>
)}
</Stack>
</TableCell>
<TableCell>
<Stack spacing={0.25}>
{(r.amountRaw || r.assetCode) && (
<Typography variant="body2" sx={{ fontFamily: 'ui-monospace, monospace', fontSize: 12 }}>
{r.amountRaw ?? '—'} {r.assetCode ?? ''}
{r.network ? ` · ${r.network}` : ''}
</Typography>
)}
<Typography variant="caption" sx={{ fontFamily: 'ui-monospace, monospace', opacity: 0.75 }}>
{shortAddr(r.fromAddress)} → {shortAddr(r.toAddress)}
</Typography>
</Stack>
</TableCell>
<TableCell>
<Chip
size="small"
label={`${r.quorumProgress.approved}/${r.quorumProgress.required}`}
color={r.quorumProgress.approved > 0 ? 'info' : 'default'}
/>
</TableCell>
<TableCell sx={{ fontFamily: 'monospace', fontSize: 12 }}>
{r.requestedBy.slice(0, 8)}…
{shortId(r.requestedBy)}
</TableCell>
<TableCell>{new Date(r.createdAt).toLocaleString()}</TableCell>
<TableCell>
@ -159,12 +225,17 @@ export function ApprovalsPage() {
<Button
size="small"
variant="contained"
disabled={approveMut.isPending}
disabled={approveMut.isPending || !r.canVote}
onClick={() => void approveMut.mutateAsync(r.id)}
>
{t('admin.approvals.approve')}
</Button>
<Button size="small" color="error" onClick={() => setRejectId(r.id)}>
<Button
size="small"
color="error"
disabled={rejectMut.isPending}
onClick={() => setRejectId(r.id)}
>
{t('admin.approvals.reject')}
</Button>
</Stack>

View File

@ -20,6 +20,7 @@ import HeadsetMicRoundedIcon from '@mui/icons-material/HeadsetMicRounded';
import HelpOutlineRoundedIcon from '@mui/icons-material/HelpOutlineRounded';
import AdminPanelSettingsRoundedIcon from '@mui/icons-material/AdminPanelSettingsRounded';
import ManageAccountsRoundedIcon from '@mui/icons-material/ManageAccountsRounded';
import RuleFolderRoundedIcon from '@mui/icons-material/RuleFolderRounded';
import { useNavigate } from 'react-router-dom';
import { useTranslation } from 'react-i18next';
import { useAuth } from '../../shared/auth/AuthContext';
@ -30,6 +31,7 @@ type OptionCardKey =
| 'settings'
| 'catalog'
| 'treasury'
| 'approvalPolicies'
| 'referral'
| 'referralFraud'
| 'testWallet'
@ -90,6 +92,15 @@ const OPTION_CARDS: OptionCardConfig[] = [
bg: 'rgba(41,182,246,0.16)',
border: 'rgba(41,182,246,0.22)',
},
{
key: 'approvalPolicies',
path: '/admin/approval-policies',
icon: RuleFolderRoundedIcon,
badgeKey: 'nOfM',
badgeColor: 'warning',
bg: 'rgba(255,152,0,0.14)',
border: 'rgba(255,152,0,0.28)',
},
{
key: 'referral',
path: '/admin/referral',

View File

@ -1,5 +1,5 @@
/**
* Admin treasury: cold wallets, sweeps, cold → hot funding.
* Admin treasury: cold wallets, sweeps, Hot ↔ Cold USDT funding, gas transfers.
* Admins work in human USDT; raw chain units are derived for the API.
*/
import {
@ -135,6 +135,27 @@ type GasPreview = {
maxSendable: string;
};
type HotToColdUsdtPreview = {
walletTypeId: number;
network: string;
walletCode: string;
tokenSymbol: string;
tokenDecimals: number;
fromHot: string;
toCold: string;
hotUsdt: string;
coldUsdt: string;
hotNative: string;
nativeSymbol: string;
nativeDecimals: number;
minNativeForWithdraw: string;
txFeeBuffer: string;
minUsdtReserve: string;
maxSendable: string;
gasOk: boolean;
gasHint: string | null;
};
/** Precise human → raw (avoids float errors on 18-decimal BEP20). */
function humanAmountToRaw(human: string, decimals: number): string {
const cleaned = human.replace(/,/g, '').replace(/\s/g, '').trim();
@ -270,6 +291,7 @@ export function TreasuryAdminPage() {
const [coldForms, setColdForms] = useState<Record<number, { address: string; label: string }>>({});
const [fundingForm, setFundingForm] = useState({
walletTypeId: 0,
direction: 'cold_to_hot' as 'cold_to_hot' | 'hot_to_cold',
amountUsdt: '',
notes: '',
});
@ -398,6 +420,20 @@ export function TreasuryAdminPage() {
});
const gasPreview = gasPreviewQ.data;
const hotToColdUsdtPreviewQ = useQuery({
queryKey: ['admin-treasury-hot-to-cold-usdt-preview', fundingForm.walletTypeId],
queryFn: async () => {
const res = await api.get<HotToColdUsdtPreview>(
'/api/v1/admin/treasury/funding/hot-to-cold/preview',
{ params: { walletTypeId: fundingForm.walletTypeId } }
);
return res.data;
},
enabled: fundingForm.walletTypeId > 0 && fundingForm.direction === 'hot_to_cold',
retry: false,
});
const hotToColdUsdtPreview = hotToColdUsdtPreviewQ.data;
const setColdMut = useMutation({
mutationFn: (body: { walletTypeId: number; address: string; label?: string }) =>
api.post('/api/v1/admin/treasury/cold-wallets', body),
@ -416,14 +452,39 @@ export function TreasuryAdminPage() {
});
const requestFundingMut = useMutation({
mutationFn: (body: { walletTypeId: number; amount: string; notes?: string }) =>
api.post<{ message?: string }>('/api/v1/admin/treasury/funding', body),
onSuccess: (res) => {
setPendingMsg(res.data.message ?? t('admin.treasury.fundingPending'));
mutationFn: (body: {
walletTypeId: number;
amount: string;
notes?: string;
direction: 'cold_to_hot' | 'hot_to_cold';
}) =>
body.direction === 'hot_to_cold'
? api.post<{ message?: string }>('/api/v1/admin/treasury/funding/hot-to-cold', {
walletTypeId: body.walletTypeId,
amount: body.amount,
notes: body.notes,
})
: api.post<{ message?: string }>('/api/v1/admin/treasury/funding', {
walletTypeId: body.walletTypeId,
amount: body.amount,
notes: body.notes,
}),
onSuccess: (res, vars) => {
setPendingMsg(
res.data.message ??
(vars.direction === 'hot_to_cold'
? t('admin.treasury.hotToColdPending')
: t('admin.treasury.fundingPending'))
);
void qc.invalidateQueries({ queryKey: ['admin-treasury-overview'] });
void qc.invalidateQueries({ queryKey: ['admin-treasury-hot-to-cold-usdt-preview'] });
void qc.invalidateQueries({ queryKey: ['admin-fund-requests'] });
setFundingForm((f) => ({ ...f, amountUsdt: '', notes: '' }));
setFundingError(null);
},
onError: (err) => {
setFundingError(apiErrorMessage(err, t('admin.treasury.fundingRequestFailed')));
},
});
const requestGasMut = useMutation({
@ -478,10 +539,30 @@ export function TreasuryAdminPage() {
setFundingError(t('admin.treasury.invalidAmount'));
return;
}
if (fundingForm.direction === 'hot_to_cold') {
if (!hotToColdUsdtPreview) {
setFundingError(t('admin.treasury.hotToColdPreviewError'));
return;
}
if (!hotToColdUsdtPreview.gasOk) {
setFundingError(hotToColdUsdtPreview.gasHint ?? t('admin.treasury.hotToColdGasInsufficient'));
return;
}
try {
if (BigInt(raw) > BigInt(hotToColdUsdtPreview.maxSendable)) {
setFundingError(t('admin.treasury.hotToColdExceedsMax'));
return;
}
} catch {
setFundingError(t('admin.treasury.invalidAmount'));
return;
}
}
void requestFundingMut.mutateAsync({
walletTypeId: fundingForm.walletTypeId,
amount: raw,
notes: fundingForm.notes || undefined,
direction: fundingForm.direction,
});
};
@ -955,7 +1036,7 @@ export function TreasuryAdminPage() {
</CardContent>
</Card>
{/* Cold → Hot */}
{/* Hot ↔ Cold USDT */}
<Card variant="outlined" sx={{ borderRadius: 2.5 }}>
<CardContent sx={{ p: { xs: 2, sm: 2.5 } }}>
<Stack direction="row" spacing={1} alignItems="center" sx={{ mb: 0.5 }}>
@ -964,13 +1045,15 @@ export function TreasuryAdminPage() {
{t('admin.treasury.fundingTitle')}
</Typography>
</Stack>
<Typography variant="body2" sx={{ opacity: 0.72, mb: 2, maxWidth: 640 }}>
<Typography variant="body2" sx={{ opacity: 0.72, mb: 2, maxWidth: 720 }}>
{t('admin.treasury.fundingSubtitle')}
</Typography>
<Stack spacing={1.5} sx={{ mb: 2 }}>
<Typography variant="caption" sx={{ opacity: 0.6 }}>
{t('admin.treasury.fundingSteps')}
{fundingForm.direction === 'hot_to_cold'
? t('admin.treasury.fundingStepsHotToCold')
: t('admin.treasury.fundingSteps')}
</Typography>
<Stack spacing={1.25}>
<Stack
@ -1000,6 +1083,24 @@ export function TreasuryAdminPage() {
))}
</Select>
</FormControl>
<FormControl size="small" sx={{ minWidth: { xs: '100%', sm: 260 }, flex: '0 1 auto' }}>
<InputLabel id="treasury-funding-dir">{t('admin.treasury.fundingDirection')}</InputLabel>
<Select
labelId="treasury-funding-dir"
label={t('admin.treasury.fundingDirection')}
value={fundingForm.direction}
onChange={(e) =>
setFundingForm((f) => ({
...f,
direction: e.target.value as 'cold_to_hot' | 'hot_to_cold',
amountUsdt: '',
}))
}
>
<MenuItem value="cold_to_hot">{t('admin.treasury.fundingDirColdToHot')}</MenuItem>
<MenuItem value="hot_to_cold">{t('admin.treasury.fundingDirHotToCold')}</MenuItem>
</Select>
</FormControl>
<TextField
size="small"
label={t('admin.treasury.amountUsdt')}
@ -1010,19 +1111,50 @@ export function TreasuryAdminPage() {
endAdornment: <InputAdornment position="end">USDT</InputAdornment>,
}}
helperText={
fundingRawPreview !== '0'
? t('admin.treasury.amountRawPreview', {
raw: fundingRawPreview,
decimals: fundingDecimals,
fundingForm.direction === 'hot_to_cold' && hotToColdUsdtPreview
? t('admin.treasury.hotToColdMaxSendable', {
amount: rawToHuman(
hotToColdUsdtPreview.maxSendable,
hotToColdUsdtPreview.tokenDecimals
),
})
: t('admin.treasury.amountUsdtHint')
: fundingRawPreview !== '0'
? t('admin.treasury.amountRawPreview', {
raw: fundingRawPreview,
decimals: fundingDecimals,
})
: t('admin.treasury.amountUsdtHint')
}
sx={{ width: { xs: '100%', sm: 160 }, flex: '0 0 auto' }}
/>
{fundingForm.direction === 'hot_to_cold' &&
hotToColdUsdtPreview &&
BigInt(hotToColdUsdtPreview.maxSendable) > 0n && (
<Button
size="small"
onClick={() =>
setFundingForm((f) => ({
...f,
amountUsdt: rawToHuman(
hotToColdUsdtPreview.maxSendable,
hotToColdUsdtPreview.tokenDecimals
),
}))
}
sx={{ alignSelf: { xs: 'stretch', sm: 'flex-start' }, mt: { sm: 0.25 }, minHeight: 40 }}
>
{t('admin.treasury.gasUseMax')}
</Button>
)}
<PermissionGate permission="admin.treasury.manage">
<Button
variant="contained"
disabled={requestFundingMut.isPending || !fundingForm.amountUsdt.trim()}
disabled={
requestFundingMut.isPending ||
!fundingForm.amountUsdt.trim() ||
(fundingForm.direction === 'hot_to_cold' &&
(!hotToColdUsdtPreview?.gasOk || hotToColdUsdtPreviewQ.isError))
}
onClick={submitFunding}
sx={{
whiteSpace: 'nowrap',
@ -1031,7 +1163,9 @@ export function TreasuryAdminPage() {
minHeight: 40,
}}
>
{t('admin.treasury.requestFunding')}
{fundingForm.direction === 'hot_to_cold'
? t('admin.treasury.requestHotToCold')
: t('admin.treasury.requestFunding')}
</Button>
</PermissionGate>
</Stack>
@ -1044,6 +1178,27 @@ export function TreasuryAdminPage() {
sx={{ maxWidth: 360, width: '100%' }}
/>
</Stack>
{fundingForm.direction === 'hot_to_cold' && hotToColdUsdtPreview && (
<Alert severity={hotToColdUsdtPreview.gasOk ? 'info' : 'warning'} sx={{ maxWidth: 720 }}>
{hotToColdUsdtPreview.gasHint ??
t('admin.treasury.hotToColdPreviewHint', {
hot: rawToHuman(hotToColdUsdtPreview.hotUsdt, hotToColdUsdtPreview.tokenDecimals),
cold: rawToHuman(hotToColdUsdtPreview.coldUsdt, hotToColdUsdtPreview.tokenDecimals),
reserve: rawToHuman(
hotToColdUsdtPreview.minUsdtReserve,
hotToColdUsdtPreview.tokenDecimals
),
native: rawToHuman(
hotToColdUsdtPreview.hotNative,
hotToColdUsdtPreview.nativeDecimals
),
symbol: hotToColdUsdtPreview.nativeSymbol,
})}
</Alert>
)}
{fundingForm.direction === 'hot_to_cold' && hotToColdUsdtPreviewQ.isError && (
<Alert severity="warning">{t('admin.treasury.hotToColdPreviewError')}</Alert>
)}
{fundingError && (
<Alert severity="warning" onClose={() => setFundingError(null)}>
{fundingError}
@ -1054,18 +1209,41 @@ export function TreasuryAdminPage() {
<Typography variant="subtitle2" sx={{ fontWeight: 700 }}>
{t('admin.treasury.fundingAddresses')}
</Typography>
<AddressField
label={t('admin.treasury.copyColdForTransfer')}
address={selectedFundingAsset.coldWallet.address}
network={selectedFundingAsset.walletType.network}
onCopied={notifyCopy}
/>
<AddressField
label={t('admin.treasury.copyHotDestination')}
address={selectedFundingAsset.hotWallet.address}
network={selectedFundingAsset.walletType.network}
onCopied={notifyCopy}
/>
{fundingForm.direction === 'hot_to_cold' ? (
<>
<AddressField
label={t('admin.treasury.copyHotSource')}
address={
hotToColdUsdtPreview?.fromHot ?? selectedFundingAsset.hotWallet.address
}
network={selectedFundingAsset.walletType.network}
onCopied={notifyCopy}
/>
<AddressField
label={t('admin.treasury.copyColdDestination')}
address={
hotToColdUsdtPreview?.toCold ?? selectedFundingAsset.coldWallet.address
}
network={selectedFundingAsset.walletType.network}
onCopied={notifyCopy}
/>
</>
) : (
<>
<AddressField
label={t('admin.treasury.copyColdForTransfer')}
address={selectedFundingAsset.coldWallet.address}
network={selectedFundingAsset.walletType.network}
onCopied={notifyCopy}
/>
<AddressField
label={t('admin.treasury.copyHotDestination')}
address={selectedFundingAsset.hotWallet.address}
network={selectedFundingAsset.walletType.network}
onCopied={notifyCopy}
/>
</>
)}
</Stack>
)}
</Stack>
@ -1085,13 +1263,15 @@ export function TreasuryAdminPage() {
{overview.pendingColdToHotFunding.map((f) => {
const wt = walletById.get(f.walletTypeId);
const asset = assets.find((a) => a.walletType.id === f.walletTypeId);
const isGas = (f.direction ?? '').includes('_gas');
const dir = f.direction ?? 'cold_to_hot';
const isGas = dir.includes('_gas');
const isHotToColdUsdt = dir === 'hot_to_cold';
const dec = isGas
? (asset?.nativeDecimals ?? (wt?.network === 'TRON' ? 6 : 18))
: (wt?.decimals ?? 18);
const symbol = isGas ? (asset?.nativeSymbol ?? 'BNB') : 'USDT';
const needsConfirm =
!isGas || f.direction === 'cold_to_hot_gas';
(!isGas && !isHotToColdUsdt) || dir === 'cold_to_hot_gas';
return (
<TableRow key={f.id}>
<TableCell>
@ -1102,7 +1282,9 @@ export function TreasuryAdminPage() {
label={
isGas
? t('admin.treasury.fundingKindGas')
: t('admin.treasury.fundingKindUsdt')
: isHotToColdUsdt
? t('admin.treasury.fundingKindHotToCold')
: t('admin.treasury.fundingKindUsdt')
}
/>
</Stack>

View File

@ -21,6 +21,8 @@ const LEGACY_IMPLIES: Record<string, string[]> = {
'user.manage_roles': ['admin.rbac.view', 'admin.rbac.manage'],
'fund_operation.request': ['admin.fund_operations.request'],
'fund_operation.approve': ['admin.fund_operations.approve'],
'approval_policy.view': ['admin.approval_policies.view'],
'approval_policy.manage': ['admin.approval_policies.manage'],
};
function expand(userPerms: string[]): Set<string> {
@ -58,6 +60,7 @@ export const ADMIN_PAGE_PERMISSIONS: Record<string, string> = {
'/admin/catalog': 'admin.games.view',
'/admin/treasury': 'admin.treasury.view',
'/admin/approvals': 'admin.fund_operations.approve',
'/admin/approval-policies': 'admin.approval_policies.view',
'/admin/security': 'admin.security.view',
'/admin/referral': 'admin.referral.view',
'/admin/referral/fraud': 'admin.referral_fraud.view',
@ -77,6 +80,7 @@ export const OPTIONS_CARD_PERMISSIONS: Record<string, string> = {
settings: 'admin.settings.view',
catalog: 'admin.games.view',
treasury: 'admin.treasury.view',
approvalPolicies: 'admin.approval_policies.view',
referral: 'admin.referral.view',
referralFraud: 'admin.referral_fraud.view',
testWallet: 'admin.test_wallet.view',

View File

@ -65,6 +65,7 @@ export const en = {
faq: 'FAQ',
support: 'Support',
approvals: 'Approvals',
approvalPolicies: 'Approval policies',
overview: 'Overview',
reports: 'Reports',
options: 'Options',
@ -957,6 +958,7 @@ export const en = {
dynamic: 'Dynamic',
catalog: 'Catalog',
coldHot: 'Cold / Hot',
nOfM: 'N-of-M',
levelsBonus: 'Levels / Bonus',
sybilReview: 'Sybil / Review / Clawback',
playMoney: 'Play money',
@ -986,6 +988,11 @@ export const en = {
title: 'Treasury',
description: 'Cold wallet addresses, deposit sweeps, and hot wallet funding from cold storage.',
},
approvalPolicies: {
title: 'Approval policies',
description:
'N-of-M rules, amount thresholds, auto-execute, and self-approval controls for sensitive ops.',
},
referral: {
title: 'Referral program',
description: 'Multi-level commissions, bonus pool, eligibility rules, and signup analytics.',
@ -1117,14 +1124,18 @@ export const en = {
},
approvals: {
title: 'Approvals',
subtitle: 'Review and approve sensitive fund operations',
subtitle: 'Review and approve sensitive fund operations (N-of-M when configured)',
refresh: 'Refresh approvals',
noPermission: 'You do not have permission to approve fund operations.',
approved: 'Request approved and executed.',
approved: 'Vote recorded — executed when quorum is complete.',
rejected: 'Request rejected.',
approveFailed: 'Approval failed',
rejectFailed: 'Rejection failed',
loadError: 'Failed to load approval queue.',
noPending: 'No pending approvals.',
type: 'Type',
details: 'Details',
quorum: 'Quorum',
requestedBy: 'Requested by',
created: 'Created',
status: 'Status',
@ -1137,13 +1148,51 @@ export const en = {
opTypes: {
ledger_credit: 'Ledger credit',
treasury_cold_to_hot: 'Cold → Hot funding',
treasury_hot_to_cold: 'Hot → Cold funding',
bonus_pool_fund: 'Bonus pool fund',
sweep_manual: 'Manual sweeps',
sweep_batch: 'Auto sweep batch',
treasury_hot_to_cold_gas: 'Hot → Cold gas (BNB / TRX)',
treasury_cold_to_hot_gas: 'Cold → Hot gas (BNB / TRX)',
user_withdrawal: 'Large user withdrawal',
approval_policy_change: 'Approval policy change',
},
},
approvalPolicies: {
title: 'Approval policies',
subtitle:
'Configure who must approve sensitive operations, amount thresholds, auto-execute, and self-approval rules.',
refresh: 'Refresh policies',
noPermission: 'You do not have permission to view approval policies.',
submitHint:
'Edits are not saved directly. Submit a change to Approvals; another Super Admin must approve before it applies.',
submitted: 'Policy change submitted — pending Approvals',
submitFailed: 'Could not submit policy change',
name: 'Name',
priority: 'Priority',
operationType: 'Operation',
anyOp: 'Any operation',
mode: 'Mode',
modeRequire: 'Require approvals',
modeAuto: 'Auto-execute',
enabled: 'Enabled',
amountMin: 'Min amount (raw)',
amountMax: 'Max amount (raw)',
network: 'Network',
forbidSelf: 'Forbid self-approval',
quorumHint: 'Quorum slots (role × count). First matching policy by priority wins.',
role: 'Role',
count: 'Count',
addSlot: 'Add slot',
removePolicy: 'Remove policy',
addPolicy: 'Add policy',
note: 'Change note',
submitChange: 'Submit change for approval',
history: 'Applied revisions',
when: 'When',
actor: 'Actor',
noHistory: 'No revisions yet.',
},
users: {
title: 'Users',
subtitle: 'Advanced user table — filter, sort, select multiple users, and run batch actions.',
@ -1574,6 +1623,7 @@ export const en = {
gasRequestFailed: 'Gas transfer request failed',
fundingKindUsdt: 'USDT',
fundingKindGas: 'Gas',
fundingKindHotToCold: 'Hot → Cold',
confirmDialogHintGas:
'Paste the blockchain transaction hash after you sent BNB or TRX from cold to hot.',
viewOnExplorer: 'Explorer',
@ -1581,10 +1631,15 @@ export const en = {
coldAddress: 'Cold wallet address',
label: 'Label',
saveCold: 'Save cold',
fundingTitle: 'Cold → Hot funding',
fundingTitle: 'Hot ↔ Cold USDT',
fundingSubtitle:
'Request approval, send USDT manually from cold to hot, then confirm with the blockchain transaction ID.',
'Move USDT between hot and cold. Cold → Hot is manual (MetaMask + Confirm). Hot → Cold is signed by the platform after Approvals.',
fundingSteps: '1) Request · 2) Approve · 3) Transfer on-chain · 4) Confirm tx',
fundingStepsHotToCold:
'1) Request · 2) Super Admin approves · 3) Platform sends USDT from hot to cold (no MetaMask)',
fundingDirection: 'Route',
fundingDirColdToHot: 'Cold → Hot (manual)',
fundingDirHotToCold: 'Hot → Cold (platform)',
network: 'Network',
amountUsdt: 'Amount',
amountUsdtHint: 'Enter a human amount, e.g. 0.50',
@ -1595,9 +1650,21 @@ export const en = {
fundingAddresses: 'Addresses for the on-chain transfer',
copyColdForTransfer: 'From (cold) — source of funds',
copyHotDestination: 'To (hot) — paste this on your exchange / wallet',
copyHotSource: 'From (hot) — platform-signed source',
copyColdDestination: 'To (cold) — active cold only',
notes: 'Notes',
notesOptional: 'Optional',
requestFunding: 'Request funding',
requestHotToCold: 'Request hot → cold',
hotToColdMaxSendable: 'Max sendable: {{amount}} USDT (after reserve)',
hotToColdPreviewHint:
'Hot {{hot}} USDT · Cold {{cold}} USDT · Reserve {{reserve}} USDT · Hot gas {{native}} {{symbol}}',
hotToColdPreviewError: 'Could not load hot → cold balances for this network',
hotToColdGasInsufficient: 'Hot wallet needs more native gas before this transfer',
hotToColdExceedsMax: 'Amount exceeds max sendable after the USDT reserve',
hotToColdPending:
'Hot → cold request submitted — after approval the platform sends from hot',
fundingRequestFailed: 'Funding request failed',
amount: 'Amount',
fromTo: 'From → To',
confirmTx: 'Confirm tx',

View File

@ -65,6 +65,7 @@ export const fr = {
faq: 'FAQ',
support: 'Assistance',
approvals: 'Approbations',
approvalPolicies: 'Règles d’approbation',
overview: 'Vue d’ensemble',
reports: 'Rapports',
options: 'Options',
@ -971,6 +972,7 @@ export const fr = {
dynamic: 'Dynamique',
catalog: 'Catalogue',
coldHot: 'Froid / Chaud',
nOfM: 'N-sur-M',
levelsBonus: 'Niveaux / Bonus',
sybilReview: 'Sybil / Revue / Récupération',
playMoney: 'Argent fictif',
@ -1000,6 +1002,11 @@ export const fr = {
title: 'Trésorerie',
description: 'Adresses cold wallet, sweeps de dépôts et alimentation du hot wallet depuis le cold storage.',
},
approvalPolicies: {
title: 'Règles d’approbation',
description:
'Règles N-sur-M, seuils de montant, auto-exécution et contrôle d’auto-approbation.',
},
referral: {
title: 'Programme de parrainage',
description: 'Commissions multi-niveaux, pool bonus, règles d’éligibilité et statistiques d’inscription.',
@ -1133,14 +1140,18 @@ export const fr = {
},
approvals: {
title: 'Approbations',
subtitle: 'Examiner et approuver les opérations de fonds sensibles',
subtitle: 'Examiner et approuver les opérations de fonds sensibles (N-sur-M si configuré)',
refresh: 'Actualiser les approbations',
noPermission: 'Vous n’avez pas la permission d’approuver les opérations de fonds.',
approved: 'Demande approuvée et exécutée.',
approved: 'Vote enregistré — exécution quand le quorum est atteint.',
rejected: 'Demande rejetée.',
approveFailed: 'Échec de l’approbation',
rejectFailed: 'Échec du rejet',
loadError: 'Impossible de charger la file d’approbation.',
noPending: 'Aucune approbation en attente.',
type: 'Type',
details: 'Détails',
quorum: 'Quorum',
requestedBy: 'Demandé par',
created: 'Créé le',
status: 'Statut',
@ -1153,13 +1164,51 @@ export const fr = {
opTypes: {
ledger_credit: 'Crédit grand livre',
treasury_cold_to_hot: 'Alimentation Froid → Chaud',
treasury_hot_to_cold: 'Alimentation Chaud → Froid',
bonus_pool_fund: 'Alimentation pool bonus',
sweep_manual: 'Sweeps manuels',
sweep_batch: 'Lot de sweeps auto',
treasury_hot_to_cold_gas: 'Gas Hot → Cold (BNB / TRX)',
treasury_cold_to_hot_gas: 'Gas Cold → Hot (BNB / TRX)',
user_withdrawal: 'Retrait utilisateur important',
approval_policy_change: 'Changement de règles d’approbation',
},
},
approvalPolicies: {
title: 'Règles d’approbation',
subtitle:
'Configurer qui doit approuver, les seuils, l’auto-exécution et l’interdiction d’auto-approbation.',
refresh: 'Actualiser les règles',
noPermission: 'Vous n’avez pas la permission de voir les règles d’approbation.',
submitHint:
'Les modifications ne sont pas enregistrées directement. Soumettez un changement vers Approvals ; un autre Super Admin doit approuver avant application.',
submitted: 'Changement de règles soumis — en attente d’Approvals',
submitFailed: 'Impossible de soumettre le changement',
name: 'Nom',
priority: 'Priorité',
operationType: 'Opération',
anyOp: 'Toute opération',
mode: 'Mode',
modeRequire: 'Approbations requises',
modeAuto: 'Exécution auto',
enabled: 'Activée',
amountMin: 'Montant min (brut)',
amountMax: 'Montant max (brut)',
network: 'Réseau',
forbidSelf: 'Interdire l’auto-approbation',
quorumHint: 'Slots de quorum (rôle × nombre). La première règle matchée par priorité gagne.',
role: 'Rôle',
count: 'Nombre',
addSlot: 'Ajouter un slot',
removePolicy: 'Supprimer la règle',
addPolicy: 'Ajouter une règle',
note: 'Note du changement',
submitChange: 'Soumettre pour approbation',
history: 'Révisions appliquées',
when: 'Quand',
actor: 'Acteur',
noHistory: 'Aucune révision pour le moment.',
},
users: {
title: 'Utilisateurs',
subtitle: 'Table avancée — filtrer, trier, sélectionner plusieurs utilisateurs et actions groupées.',
@ -1590,6 +1639,7 @@ export const fr = {
gasRequestFailed: 'La demande de transfert de gas a échoué',
fundingKindUsdt: 'USDT',
fundingKindGas: 'Gas',
fundingKindHotToCold: 'Hot → Cold',
confirmDialogHintGas:
'Collez le hash de transaction après avoir envoyé du BNB ou TRX du cold vers le hot.',
viewOnExplorer: 'Explorateur',
@ -1597,10 +1647,15 @@ export const fr = {
coldAddress: 'Adresse cold wallet',
label: 'Libellé',
saveCold: 'Enregistrer cold',
fundingTitle: 'Alimentation Cold → Hot',
fundingTitle: 'USDT Hot ↔ Cold',
fundingSubtitle:
'Demandez l’approbation, envoyez l’USDT manuellement du cold vers le hot, puis confirmez avec l’ID de transaction blockchain.',
'Déplacez l’USDT entre hot et cold. Cold → Hot est manuel (MetaMask + Confirmer). Hot → Cold est signé par la plateforme après Approvals.',
fundingSteps: '1) Demande · 2) Approbation · 3) Transfert on-chain · 4) Confirmer la tx',
fundingStepsHotToCold:
'1) Demande · 2) Super Admin approuve · 3) La plateforme envoie l’USDT du hot vers le cold (pas de MetaMask)',
fundingDirection: 'Parcours',
fundingDirColdToHot: 'Cold → Hot (manuel)',
fundingDirHotToCold: 'Hot → Cold (plateforme)',
network: 'Réseau',
amountUsdt: 'Montant',
amountUsdtHint: 'Saisissez un montant lisible, ex. 0.50',
@ -1611,9 +1666,21 @@ export const fr = {
fundingAddresses: 'Adresses pour le transfert on-chain',
copyColdForTransfer: 'De (cold) — source des fonds',
copyHotDestination: 'Vers (hot) — à coller dans l’échangeur / wallet',
copyHotSource: 'De (hot) — source signée par la plateforme',
copyColdDestination: 'Vers (cold) — cold actif uniquement',
notes: 'Notes',
notesOptional: 'Facultatif',
requestFunding: 'Demander le financement',
requestHotToCold: 'Demander hot → cold',
hotToColdMaxSendable: 'Max envoyable : {{amount}} USDT (après réserve)',
hotToColdPreviewHint:
'Hot {{hot}} USDT · Cold {{cold}} USDT · Réserve {{reserve}} USDT · Gas hot {{native}} {{symbol}}',
hotToColdPreviewError: 'Impossible de charger les soldes hot → cold pour ce réseau',
hotToColdGasInsufficient: 'Le hot wallet a besoin de plus de gas natif avant ce transfert',
hotToColdExceedsMax: 'Le montant dépasse le maximum envoyable après la réserve USDT',
hotToColdPending:
'Demande hot → cold soumise — après approbation la plateforme envoie depuis le hot',
fundingRequestFailed: 'La demande de financement a échoué',
amount: 'Montant',
fromTo: 'De → Vers',
confirmTx: 'Confirmer tx',

View File

@ -27,6 +27,7 @@ import AssessmentRoundedIcon from '@mui/icons-material/AssessmentRounded';
import SecurityRoundedIcon from '@mui/icons-material/SecurityRounded';
import HeadsetMicRoundedIcon from '@mui/icons-material/HeadsetMicRounded';
import GavelRoundedIcon from '@mui/icons-material/GavelRounded';
import RuleFolderRoundedIcon from '@mui/icons-material/RuleFolderRounded';
import { PrediqoLogo } from '../brand/PrediqoLogo';
import HelpOutlineRoundedIcon from '@mui/icons-material/HelpOutlineRounded';
import Badge from '@mui/material/Badge';
@ -184,9 +185,18 @@ export function AppShell() {
...(canApproveFundOps
? [{ label: t('nav.approvals'), to: '/admin/approvals', icon: <GavelRoundedIcon /> }]
: []),
...(can('admin.approval_policies.view') || can('approval_policy.view')
? [
{
label: t('nav.approvalPolicies'),
to: '/admin/approval-policies',
icon: <RuleFolderRoundedIcon />,
},
]
: []),
...(hasAdminPanel || isAdmin ? adminNavItems : []),
] as const,
[t, isAdmin, hasAdminPanel, isStaff, canApproveFundOps, unreadSupport, adminNavItems]
[t, isAdmin, hasAdminPanel, isStaff, canApproveFundOps, can, unreadSupport, adminNavItems]
);
const drawer = (