
Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
一句话总结:交易监控系统(TMS)是一个覆盖"事前采集 → 事中检测 → 事后调查"全生命周期的准实时/离线风险识别与案件处置平台;与实时风控引擎的毫秒级拦截不同,TMS 的核心价值在于跨时间窗口的异常模式识别(如 30 天内多笔小额试探后大额出金)和合规报告生成(SAR/STR),其架构灵魂在于 Lambda 架构的实时+离线双轨计算、规则 DSL 的灵活编排、以及案件工作流的状态机驱动。
1. 概念定义(是什么)
1.1 Transaction Monitoring System(交易监控系统)
交易监控系统(TMS) 是金融机构用于检测、分析和报告可疑交易活动的事后/准实时分析平台。其核心目标不是替代实时风控引擎的毫秒级拦截,而是弥补实时引擎在时间窗口、关联分析和合规审计方面的天然短板。
与实时风控引擎的差异对比:
| 维度 | 实时风控引擎(Real-time Risk Engine) | 交易监控系统(TMS) |
|---|---|---|
| 时间窗口 | 单笔交易,毫秒级 | 跨交易、跨用户、跨时间(分钟~年) |
| 延迟要求 | P99 < 50ms(同步阻塞) | 准实时 < 5min,离线 T+1 |
| 核心能力 | 快速拦截已知风险模式 | 发现未知异常模式、生成合规报告 |
| 决策影响 | 阻断/放行当前交易 | 冻结账户、上报监管、触发调查 |
| 规则复杂度 | 简单规则(黑名单、阈值) | 复杂关联规则(图谱、时序、统计) |
| 典型输出 | PASS / REJECT / REVIEW | Alert(告警)→ Case(案件)→ SAR(可疑报告) |
1.2 核心概念词典
| 术语 | 英文 | 定义 |
|---|---|---|
| 可疑交易 | Suspicious Transaction | 金额、频率、对手方、路径等维度偏离用户历史基线或监管阈值的交易 |
| 告警(Alert) | Alert | 规则/模型命中后生成的待审核风险信号,含风险等级、命中规则、证据链 |
| 案件(Case) | Case | 由一个或多个关联 Alert 聚合而成的调查单元,含工作流状态 |
| SAR/STR | Suspicious Activity/Transaction Report | 向监管机构(FinCEN、FCA、香港 SFC 等)提交的可疑活动报告 |
| Travel Rule | Travel Rule | FATF Recommendation 16,要求 VASP 间传输 >= 1000 USD 的加密资产时交换 KYC 信息 |
| CEP | Complex Event Processing | 复杂事件处理,用于识别跨时间窗口的交易序列模式 |
| Rule DSL | Domain Specific Language | 面向风控运营的规则声明语言,支持非研发人员配置检测逻辑 |
1.3 类比理解:TMS = 医院的"疑难杂症会诊中心"
类比:医院会诊中心 vs 交易监控系统
- 实时风控引擎 = 急诊室分诊台:病人(交易)来了,快速判断"生死"(拦截/放行),处理时间以分钟计
- TMS 数据采集层 = 全院病历系统:汇集门诊、住院、检验、影像等全量数据(交易流水、用户行为、KYC、设备指纹)
- TMS 异常检测层 = AI 辅助诊断系统 + 专家会诊规则:"这个病人过去 3 个月多次轻微头痛(小额试探),今天突然剧烈头痛伴呕吐(大额出金),高度怀疑脑出血(洗钱)"
- TMS 告警分级 = 病情分级(病危/病重/一般):红色(1 分钟内通知主任)、黄色(30 分钟内通知主治医师)、蓝色(每日汇总查房)
- TMS 案件管理 = 疑难病例档案:从入院(创建案件)→ 主治医师接手(分配)→ 检查化验(调查取证)→ 确诊出院(结案上报)→ 归档(合规留痕)
- SAR 报告 = 向 CDC(疾控中心)上报的传染病报告:有法定格式、法定时限、法定责任
1.4 为什么需要 TMS(解决了什么问题)
- 实时引擎的"近视"问题:实时引擎只能看到"当前这一笔",无法识别"过去 30 天内 20 笔小额充值后突然大额出金"的 Structuring( structuring, structuring)行为
- 监管合规刚性:FATF、欧盟 5AMLD、美国 BSA 要求交易所必须建立"有效的交易监控体系"并定期提交 SAR/STR
- 模型冷启动与未知风险:新出现的洗钱手法(如 2022 年 Tornado Cash 混币)无法被实时硬规则覆盖,需要离线图谱分析和行为基线偏离检测
- 审计与举证:当监管机构问询"你们为什么冻结这个账户"时,需要完整的证据链(命中规则、关联交易、模型评分、处置记录)
2. 核心原理与图解
2.1 需求分析
2.1.1 功能需求(Functional Requirements)
| 模块 | 功能点 | 优先级 |
|---|---|---|
| 数据采集 | 全量交易流水接入(spot/futures/margin/P2P/withdrawal/deposit/swap)、KYC 变更、设备登录、API Key 操作 | P0 |
| 异常检测 | 规则引擎(金额/频率/地域/对手方)、Flink CEP 时序模式、ML 异常检测(孤立森林、图神经网络) | P0 |
| 告警管理 | 告警生成、分级、去重、合并、抑制、升级 | P0 |
| 案件管理 | Case 创建→分配→调查→处置→结案→上报的全工作流 | P0 |
| 合规报告 | SAR/STR 自动生成、Travel Rule 信息交换记录、监管报送接口 | P0 |
| 运营后台 | 规则配置(DSL)、命中趋势看板、分析师效能报表 | P1 |
2.1.2 非功能需求(Non-Functional Requirements)
| 指标 | 目标值 | 说明 |
|---|---|---|
| 日交易流水量 | 5B+ | 大型加密货币交易所 级别:现货 100K TPS,合约 200K TPS,加上 P2P/理财/出金等 |
| 检测延迟 | 准实时 < 3min,离线 T+1 | 准实时用于快速冻结,离线用于深度挖掘 |
| 告警处理 QPS | 10K+ | 峰值告警生成速率 |
| 案件查询 P99 | < 500ms | 分析师操作后台的响应要求 |
| 数据保留期 | 原始流水 7 年,特征快照 3 年 | 监管要求 |
| 可用性 | 99.95% | 案件系统不可用会导致分析师无法处置紧急告警 |
2.1.3 QPS / 吞吐量 / 存储估算
以 大型加密货币交易所 量级为例:
假设:
- 日活用户 DAU = 30M
- 人均日交易笔数(含下单/撤单/成交/转账/充提)= 50 笔
- 日均交易事件 = 30M × 50 = 1.5B
- 峰值倍率 = 5× → 峰值事件 TPS ≈ 1.5B × 5 / 86400 ≈ 87K TPS
存储估算(原始流水):
- 单笔事件平均大小 = 2KB(含用户、对手方、金额、手续费、IP、设备、链上哈希等)
- 日原始数据 = 1.5B × 2KB = 3TB
- 年原始数据 = 3TB × 365 = 1.1PB
- 副本 3 + 压缩率 0.3 → 年存储 ≈ 1PB(压缩后)
特征存储(ClickHouse/StarRocks):
- 聚合特征表 = 用户维度 × 时间窗口 ≈ 30M × 20 个窗口 × 100 字段 × 8B ≈ 480GB
告警存储:
- 日均告警量(去重前)= 1.5B × 0.1% 命中率 = 1.5M
- 日均案件量 = 1.5M / 10(合并率)= 150K
- 单条告警 ≈ 5KB,单案件 ≈ 50KB(含附件/证据链)
- 日告警存储 = 1.5M × 5KB = 7.5GB
- 日案件存储 = 150K × 50KB = 7.5GB
2.2 Lambda 架构全景图
2.3 交易异常检测数据流时序图
2.4 核心检测维度详解
2.4.1 金额维度(Amount-based)
| 检测模式 | 说明 | 典型规则 |
|---|---|---|
| 大额阈值突破 | 单笔超过监管或内部阈值 | amount > 10000 USD AND user_kyc_level < 2 → ALERT |
| Structuring(拆分) | 多笔小额规避大额报告门槛 | count(amount < 10000) in 24h > 5 AND sum(amount) > 50000 → ALERT |
| 金额突增 | 偏离用户历史基线 | amount > user_30d_avg × 10 AND amount > 1000 → ALERT |
2.4.2 频率维度(Frequency-based)
| 检测模式 | 说明 | 典型规则 |
|---|---|---|
| 高频交易 | 超出正常操作频率 | withdraw_count_1h > 10 AND user_tenure_days > 30 → ALERT |
| 睡眠账户激活 | 长期 dormant 后突然活跃 | last_trade_days_ago > 90 AND today_trade_count > 3 → ALERT |
| 定时触发 | 疑似脚本操作的规律性 | stddev(intervals_of_10_trades) < 1s → BOT_ALERT |
2.4.3 地域维度(Geographic)
| 检测模式 | 说明 | 典型规则 |
|---|---|---|
| 制裁国家 | 交易涉及制裁司法管辖区 | ip_geo IN ( sanctioned_countries ) OR counterparty_geo IN (...) → BLOCK |
| 不可能旅行 | 短时间内跨越物理上不可能的地理距离 | login_ip_geo == HK (T0) AND withdraw_ip_geo == US (T0+1h) AND distance > 5000km → IMPOSSIBLE_TRAVEL |
| 高风险司法管辖区 | FATF 灰名单国家 | ANY tx_geo IN (fatf_grey_list) → RISK_SCORE + 30 |
2.4.4 对手方维度(Counterparty)
| 检测模式 | 说明 | 典型规则 |
|---|---|---|
| 黑名单地址 | 链上地址命中制裁/犯罪名单 | to_address IN (OFAC_SDN_LIST) → IMMEDIATE_BLOCK + SAR |
| 混币器交互 | 与 Tornado Cash / Samourai 等交互 | ANY tx_path_contains(TORNADO_CONTRACT) → HIGH_RISK |
| 关联交易环 | 多个账户间循环转账 | GNN 检测:transaction_graph_cycle_score > 0.85 → ALERT |
2.5 告警分级体系
| 等级 | 响应时效 | 处置方式 | 示例 |
|---|---|---|---|
| CRITICAL | < 1min | 自动冻结 + 通知合规 VP + 升级高管 | OFAC 制裁地址命中、恐怖融资关联 |
| HIGH | < 30min | 分析师立即处置 + 可选自动冻结 | 1h 内 5 笔出金至混币器、Travel Rule 信息不匹配 |
| MEDIUM | < 4h | 分析师当班内处置 | 金额突增 5 倍、新设备首次大额出金 |
| LOW | T+1 | 批量审核 + 汇总报告 | 行为基线轻微偏离、低频关联地址 |
2.6 案件管理工作流状态机
3. 语法详解与代码示例(怎么用)
3.1 交易数据采集:Kafka Producer / API 埋点
/**
* 交易事件采集器:将核心交易系统的全量交易事件标准化后写入 Kafka
* 部署于交易核心下游,采用 "至少一次" 语义 + 幂等去重保证
*/
@Component
public class TransactionEventCollector {
@Autowired
private KafkaTemplate<String, TransactionEvent> kafkaTemplate;
@Autowired
private IdempotencyChecker idempotencyChecker;
private static final String TOPIC_TX_MONITOR = "tx.monitoring.raw.v1";
private static final String TOPIC_TX_PRIORITY = "tx.monitoring.priority.v1";
/**
* 采集交易事件:由交易核心的 Spring Event 或 gRPC Stream 触发
*/
public void collect(TransactionRaw raw) {
// 1. 幂等去重:防止交易核心重试导致重复采集
String eventId = raw.getTxId() + "#" + raw.getEventType();
if (!idempotencyChecker.tryAcquire(eventId, Duration.ofHours(24))) {
log.warn("Duplicate transaction event discarded: {}", eventId);
return;
}
// 2. 标准化为监控领域事件(解耦上游交易核心模型)
TransactionEvent event = TransactionEvent.builder()
.eventId(eventId)
.txId(raw.getTxId())
.userId(raw.getUserId())
.eventType(mapEventType(raw.getType())) // SPOT_ORDER, FUTURES_TRADE, WITHDRAW, DEPOSIT, P2P_RELEASE, SWAP
.timestamp(raw.getExecutedAt())
.amount(raw.getAmount())
.currency(raw.getCurrency())
.usdEquivalent(raw.getUsdEquivalent()) // 统一折算为 USD
.fromAddress(raw.getFromAddress())
.toAddress(raw.getToAddress())
.counterpartyUserId(raw.getCounterpartyUserId())
.counterpartyType(raw.getCounterpartyType()) // INTERNAL, EXTERNAL_VASP, UNKNOWN
.ipGeo(IpGeoResolver.resolve(raw.getClientIp()))
.deviceFingerprint(raw.getDeviceFingerprint())
.sessionId(raw.getSessionId())
.kycLevel(raw.getKycLevel())
.accountAgeDays(raw.getAccountAgeDays())
.sourceSystem(raw.getSourceSystem())
.build();
// 3. 根据风险等级路由到不同 Topic(优先级队列)
String topic = shouldPriorityRoute(event) ? TOPIC_TX_PRIORITY : TOPIC_TX_MONITOR;
// 4. 发送:按 userId 分区保证用户内事件有序(CEP 依赖)
ProducerRecord<String, TransactionEvent> record = new ProducerRecord<>(
topic,
event.getUserId(), // partition key = userId
event
);
// 注入 TraceId 用于全链路追踪
record.headers().add("X-Trace-Id", MDC.get("traceId").getBytes(StandardCharsets.UTF_8));
ListenableFuture<SendResult<String, TransactionEvent>> future =
kafkaTemplate.send(record);
future.addCallback(
result -> log.debug("Tx event sent: {}", eventId),
ex -> log.error("Failed to send tx event: {}", eventId, ex)
);
}
private boolean shouldPriorityRoute(TransactionEvent event) {
// 出金、P2P 释放、涉及外部地址的交易进入优先队列
return event.getEventType() == EventType.WITHDRAW
|| event.getEventType() == EventType.P2P_RELEASE
|| event.getCounterpartyType() == CounterpartyType.EXTERNAL_VASP;
}
private EventType mapEventType(String rawType) {
return EventType.fromCode(rawType);
}
}
/**
* 交易事件标准化模型(监控领域)
*/
@Data
@Builder
public class TransactionEvent {
private String eventId; // 幂等键
private String txId; // 交易核心 ID
private String userId; // 用户 ID(Kafka partition key)
private EventType eventType; // 事件类型枚举
private Instant timestamp; // 事件时间(CEP Event Time)
private BigDecimal amount; // 原始金额
private String currency; // 币种
private BigDecimal usdEquivalent; // 美元折算(统一口径)
private String fromAddress; // 链上 from(提现为热钱包地址)
private String toAddress; // 链上 to(外部地址)
private String counterpartyUserId; // 对手方用户(C2C/P2P)
private CounterpartyType counterpartyType;
private GeoInfo ipGeo; // IP 地理位置
private String deviceFingerprint;
private String sessionId;
private int kycLevel; // KYC 等级
private int accountAgeDays; // 账户年龄
private String sourceSystem; // 来源系统
}3.2 异常检测规则引擎 DSL 定义
/**
* 风控规则 DSL 定义与编译执行
* 目标:让合规运营同学通过 JSON/YAML 配置规则,无需发版
*/
public class RuleDslDefinitions {
/**
* 规则 DSL JSON 示例:大额提现 + 新设备 + 高风险国家
*/
public static final String RULE_WITHDRAW_HIGH_RISK_GEO = """
{
"ruleId": "RULE_WD_001",
"version": "2.3",
"name": "大额提现高风险国家新设备",
"severity": "HIGH",
"category": "AML_STRUCTURING",
"enabled": true,
"salience": 90,
"window": {
"type": "SLIDING",
"size": "1h",
"triggerOn": "WITHDRAW"
},
"condition": {
"operator": "AND",
"conditions": [
{
"field": "event.usdEquivalent",
"op": "GT",
"value": 10000,
"unit": "USD"
},
{
"field": "event.ipGeo.riskLevel",
"op": "IN",
"value": ["HIGH", "CRITICAL"]
},
{
"field": "event.deviceFingerprint.trustScore",
"op": "LT",
"value": 0.3
},
{
"field": "aggregate.user.7d_withdraw_sum_usd",
"op": "GT",
"value": 50000
}
]
},
"actions": [
{ "type": "CREATE_ALERT", "severity": "HIGH", "escalationMinutes": 30 },
{ "type": "TAG_USER", "tag": "AML_HIGH_RISK" },
{ "type": "NOTIFY", "channel": "SLACK", "target": "#aml-alerts" }
],
"suppress": {
"key": "${userId}:${ruleId}",
"duration": "1h"
}
}
""";
/**
* 规则 DSL 编译为可执行对象
*/
@Component
public class RuleCompiler {
private final ObjectMapper mapper = new ObjectMapper();
public CompiledRule compile(RuleDefinition def) {
// 1. 语法校验(JSON Schema)
validateSchema(def);
// 2. 编译条件表达式为谓词链(避免运行时反射,提升性能)
List<Predicate<RuleContext>> predicates = def.getCondition().toPredicates();
// 3. 编译动作链
List<RuleAction> actions = def.getActions().stream()
.map(this::compileAction)
.toList();
// 4. 编译窗口定义(Flink / 本地滑动窗口)
WindowSpec window = compileWindow(def.getWindow());
return CompiledRule.builder()
.ruleId(def.getRuleId())
.version(def.getVersion())
.salience(def.getSalience())
.predicates(predicates)
.actions(actions)
.window(window)
.suppressKeyTemplate(def.getSuppress().getKey())
.suppressDuration(def.getSuppress().getDuration())
.build();
}
private void validateSchema(RuleDefinition def) {
// JSON Schema 校验:确保 field 引用合法、op 在枚举范围内
if (def.getCondition() == null || def.getActions().isEmpty()) {
throw new RuleCompileException("Rule must have condition and actions");
}
}
}
/**
* 规则执行上下文(包含事件 + 聚合特征 + 用户画像)
*/
@Data
@Builder
public class RuleContext {
private TransactionEvent event;
private UserProfile userProfile;
private Map<String, Object> aggregates; // 预聚合特征,如 7d_withdraw_sum_usd
private Map<String, Object> env; // 环境变量,如当前监管政策开关
}
}3.3 Flink CEP / Streaming SQL 时序模式检测
/**
* Flink CEP 复杂事件处理:识别"小额试探 → 大额出金"的 Structuring 模式
* 部署于 Flink 集群,消费 Kafka tx.monitoring.raw.v1
*/
public class FlinkStructuringDetectionJob {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env =
StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(128);
env.enableCheckpointing(60000, CheckpointingMode.EXACTLY_ONCE);
// 1. 消费 Kafka 交易流
KafkaSource<TransactionEvent> source = KafkaSource.<TransactionEvent>builder()
.setBootstrapServers("kafka.internal:9092")
.setTopics("tx.monitoring.raw.v1")
.setGroupId("flink-tms-structuring")
.setStartingOffsets(OffsetsInitializer.latest())
.setValueOnlyDeserializer(new TransactionEventDeserializationSchema())
.build();
DataStream<TransactionEvent> txStream = env.fromSource(
source, WatermarkStrategy
.<TransactionEvent>forBoundedOutOfOrderness(Duration.ofMinutes(5))
.withTimestampAssigner((event, ts) -> event.getTimestamp().toEpochMilli()),
"Transaction Source"
);
// 2. 按 userId 分区(KeyedStream),保证同一用户的交易由同一并行实例处理
KeyedStream<TransactionEvent, String> keyedStream = txStream
.keyBy(TransactionEvent::getUserId);
// 3. 定义 CEP 模式:5 笔小额提现(< 1000 USD)后 1h 内出现 1 笔大额(> 10000 USD)
Pattern<TransactionEvent, ?> structuringPattern = Pattern
.<TransactionEvent>begin("small-withdraws")
.where(evt ->
evt.getEventType() == EventType.WITHDRAW
&& evt.getUsdEquivalent().compareTo(BigDecimal.valueOf(1000)) < 0
)
.timesOrMore(5)
.greedy()
.within(Time.minutes(30))
.next("large-withdraw")
.where(evt ->
evt.getEventType() == EventType.WITHDRAW
&& evt.getUsdEquivalent().compareTo(BigDecimal.valueOf(10000)) >= 0
)
.within(Time.hours(1));
// 4. 模式匹配与处理
PatternStream<TransactionEvent> patternStream = CEP.pattern(keyedStream, structuringPattern);
DataStream<StructuringAlert> alerts = patternStream
.process(new PatternProcessFunction<TransactionEvent, StructuringAlert>() {
@Override
public void processMatch(
Map<String, List<TransactionEvent>> match,
Context ctx,
Collector<StructuringAlert> out) {
List<TransactionEvent> smallTxs = match.get("small-withdraws");
TransactionEvent largeTx = match.get("large-withdraw").get(0);
BigDecimal totalSmall = smallTxs.stream()
.map(TransactionEvent::getUsdEquivalent)
.reduce(BigDecimal.ZERO, BigDecimal::add);
out.collect(StructuringAlert.builder()
.alertId(UUID.randomUUID().toString())
.userId(largeTx.getUserId())
.patternName("STRUCTURING_SMALL_TO_LARGE")
.severity(AlertSeverity.HIGH)
.smallTxCount(smallTxs.size())
.smallTxTotalUsd(totalSmall)
.largeTxId(largeTx.getTxId())
.largeTxUsd(largeTx.getUsdEquivalent())
.timeWindowMinutes(60)
.evidenceJson(toJson(match))
.detectedAt(Instant.now())
.build());
}
});
// 5. 结果写入告警 Kafka Topic
alerts.addSink(KafkaSink.<StructuringAlert>builder()
.setBootstrapServers("kafka.internal:9092")
.setRecordSerializer(KafkaRecordSerializationSchema.builder()
.setTopic("tms.alerts.generated")
.setValueSerializationSchema(new AlertSerializationSchema())
.build())
.setDeliveryGuarantee(DeliveryGuarantee.AT_LEAST_ONCE)
.build());
env.execute("TMS Structuring Detection Job");
}
}
/**
* Flink SQL 版本:同等逻辑的声明式表达(适合分析师自助配置)
*/
@Component
public class FlinkSqlStructuringQuery {
/**
* 通过 Flink SQL 定义 structuring 检测
* 优势:无需 Java 开发,分析师在后台直接写 SQL
*/
public static final String STRUCTURING_SQL = """
CREATE TABLE tx_events (
userId STRING,
eventType STRING,
usdEquivalent DECIMAL(18,8),
eventTime TIMESTAMP(3),
WATERMARK FOR eventTime AS eventTime - INTERVAL '5' MINUTE
) WITH (
'connector' = 'kafka',
'topic' = 'tx.monitoring.raw.v1',
'properties.bootstrap.servers' = 'kafka.internal:9092',
'format' = 'json'
);
-- 检测窗口内的小额提现次数和大额提现触发
SELECT
userId,
COUNT(*) AS small_tx_count,
SUM(usdEquivalent) AS small_tx_total,
TUMBLE_START(eventTime, INTERVAL '1' HOUR) AS window_start,
TUMBLE_END(eventTime, INTERVAL '1' HOUR) AS window_end
FROM tx_events
WHERE eventType = 'WITHDRAW'
AND usdEquivalent < 1000
GROUP BY
userId,
TUMBLE(eventTime, INTERVAL '1' HOUR)
HAVING COUNT(*) >= 5
AND SUM(usdEquivalent) > 5000;
-- 关联大额提现(使用 Temporal Join)
-- 实际生产中会拆分为两个 SQL 作业,通过 Kafka Topic 串联
""";
}3.4 告警分级服务
/**
* 告警分级与路由服务:将原始命中结果转化为分级告警,并触发相应处置
*/
@Service
public class AlertGradingService {
@Autowired
private AlertRepository alertRepository;
@Autowired
private CaseManagementService caseService;
@Autowired
private NotificationService notificationService;
@Autowired
private StringRedisTemplate redisTemplate;
/**
* 告警处理主入口:实时/准实时/离线三条流水线汇聚于此
*/
public void processAlert(AlertRaw raw) {
// 1. 生成告警唯一键
String alertKey = generateAlertKey(raw);
// 2. 抑制检查(同一用户同一规则在窗口期内只生成一次)
String suppressKey = "alert:suppress:" + raw.getUserId() + ":" + raw.getRuleId();
Duration suppressWindow = raw.getSuppressDuration() != null
? raw.getSuppressDuration()
: Duration.ofHours(1);
Boolean isNew = redisTemplate.opsForValue()
.setIfAbsent(suppressKey, "1", suppressWindow);
if (Boolean.FALSE.equals(isNew)) {
log.info("Alert suppressed: {}", suppressKey);
return;
}
// 3. 分级判定(结合规则 severity + 动态风险分)
AlertSeverity severity = gradeSeverity(raw);
// 4. 构建持久化告警对象
Alert alert = Alert.builder()
.alertId(alertKey)
.userId(raw.getUserId())
.ruleId(raw.getRuleId())
.ruleName(raw.getRuleName())
.severity(severity)
.category(raw.getCategory())
.evidence(raw.getEvidenceJson())
.status(AlertStatus.PENDING)
.createdAt(Instant.now())
.slaDeadline(calculateSla(severity))
.build();
alertRepository.save(alert);
// 5. 分级处置路由
routeBySeverity(alert, raw);
}
private AlertSeverity gradeSeverity(AlertRaw raw) {
int baseScore = raw.getRuleSeverity().ordinal() * 25; // CRITICAL=100, HIGH=75, ...
// 动态加分:用户风险画像
UserRiskProfile profile = raw.getUserRiskProfile();
if (profile != null) {
if (profile.isSanctionsRelated()) baseScore += 50;
if (profile.getAmlScore() > 0.8) baseScore += 20;
if (profile.getDeviceTrustScore() < 0.2) baseScore += 15;
}
// 动态加分:金额
if (raw.getUsdEquivalent() != null) {
if (raw.getUsdEquivalent().compareTo(BigDecimal.valueOf(100000)) > 0) baseScore += 25;
else if (raw.getUsdEquivalent().compareTo(BigDecimal.valueOf(10000)) > 0) baseScore += 10;
}
return AlertSeverity.fromScore(baseScore);
}
private void routeBySeverity(Alert alert, AlertRaw raw) {
switch (alert.getSeverity()) {
case CRITICAL -> {
// 实时:自动冻结 + 通知高管 + 立即创建紧急案件
log.warn("CRITICAL ALERT triggered: {}", alert.getAlertId());
notificationService.notifyCritical(alert);
caseService.createEmergencyCase(alert);
// 可选:调用核心系统 API 临时冻结出金
// freezeService.freezeWithdrawal(alert.getUserId(), "CRITICAL_ALERT_" + alert.getAlertId());
}
case HIGH -> {
// 准实时:创建案件,分析师 30min SLA
notificationService.notifySlack("#aml-high", alert);
caseService.createCase(List.of(alert), AssignmentStrategy.LOAD_BALANCED);
}
case MEDIUM -> {
// 批量:案件池,当班分析师处理
caseService.addToPool(alert);
}
case LOW -> {
// 低优先级:先不入案件,积累到一定数量或触发升级规则后再处理
caseService.addToBatchQueue(alert);
}
}
}
private Instant calculateSla(AlertSeverity severity) {
return switch (severity) {
case CRITICAL -> Instant.now().plusSeconds(60); // 1min
case HIGH -> Instant.now().plusSeconds(30 * 60); // 30min
case MEDIUM -> Instant.now().plusSeconds(4 * 3600); // 4h
case LOW -> Instant.now().plusSeconds(24 * 3600); // 24h
};
}
private String generateAlertKey(AlertRaw raw) {
return String.format("ALT-%s-%s-%d",
raw.getUserId(),
raw.getRuleId(),
Instant.now().getEpochSecond() / 3600 // 按小时粒度
);
}
}
/**
* 告警实体
*/
@Data
@Builder
public class Alert {
private String alertId;
private String userId;
private String ruleId;
private String ruleName;
private AlertSeverity severity;
private String category;
private String evidence; // JSON 证据链
private AlertStatus status;
private Instant createdAt;
private Instant slaDeadline;
}
public enum AlertSeverity {
CRITICAL(90, 100), HIGH(70, 89), MEDIUM(40, 69), LOW(0, 39);
private final int minScore, maxScore;
AlertSeverity(int min, int max) { this.minScore = min; this.maxScore = max; }
public static AlertSeverity fromScore(int score) {
for (AlertSeverity s : values()) {
if (score >= s.minScore && score <= s.maxScore) return s;
}
return LOW;
}
}3.5 案件管理与处置流程
/**
* 案件管理服务:全生命周期工作流引擎(CREATE → ASSIGN → INVESTIGATE → RESOLVE → CLOSE)
* 状态机驱动,支持自动分配、SLA 监控、升级策略
*/
@Service
public class CaseManagementService {
@Autowired
private CaseRepository caseRepository;
@Autowired
private AnalystRepository analystRepository;
@Autowired
private StateMachine<CaseState, CaseEvent> stateMachine;
@Autowired
private ApplicationEventPublisher eventPublisher;
/**
* 创建案件:支持单告警直接建案、多告警合并建案
*/
@Transactional
public Case createCase(List<Alert> alerts, AssignmentStrategy strategy) {
String userId = alerts.get(0).getUserId();
// 检查是否已存在该用户的 OPEN 案件,有则合并
Optional<Case> existing = caseRepository.findOpenCaseByUserId(userId);
if (existing.isPresent()) {
return mergeIntoExistingCase(existing.get(), alerts);
}
// 新建案件
String caseId = "CASE-" + UUID.randomUUID().toString().substring(0, 8).toUpperCase();
Case newCase = Case.builder()
.caseId(caseId)
.userId(userId)
.alerts(new ArrayList<>(alerts))
.state(CaseState.OPEN)
.priority(calculatePriority(alerts))
.createdAt(Instant.now())
.slaDeadline(calculateCaseSla(alerts))
.tags(extractTags(alerts))
.build();
caseRepository.save(newCase);
// 自动分配分析师
assignAnalyst(newCase, strategy);
// 发布案件创建事件(用于通知、SLA 计时)
eventPublisher.publishEvent(new CaseCreatedEvent(newCase));
return newCase;
}
/**
* 创建紧急案件(CRITICAL 告警)
*/
@Transactional
public Case createEmergencyCase(Alert alert) {
Case emergencyCase = Case.builder()
.caseId("CASE-EMG-" + System.currentTimeMillis())
.userId(alert.getUserId())
.alerts(List.of(alert))
.state(CaseState.ESCALATED)
.priority(CasePriority.P0)
.createdAt(Instant.now())
.slaDeadline(Instant.now().plusSeconds(300)) // 5min SLA
.build();
caseRepository.save(emergencyCase);
// 绕过普通分配,直接指派给值班主管
Analyst dutyManager = analystRepository.findDutyManager();
emergencyCase.setAssignedAnalystId(dutyManager.getAnalystId());
emergencyCase.setState(CaseState.ASSIGNED);
caseRepository.update(emergencyCase);
eventPublisher.publishEvent(new EmergencyCaseEvent(emergencyCase));
return emergencyCase;
}
/**
* 分析师提交处置
*/
@Transactional
public void submitDisposition(String caseId, String analystId, DispositionRequest req) {
Case caseEntity = caseRepository.findById(caseId)
.orElseThrow(() -> new CaseNotFoundException(caseId));
// 状态机校验:只能从 UNDER_INVESTIGATION → PENDING_REVIEW
if (caseEntity.getState() != CaseState.UNDER_INVESTIGATION) {
throw new InvalidStateTransitionException(
caseEntity.getState(), CaseEvent.SUBMIT_DISPOSITION);
}
// 更新处置内容
caseEntity.setDisposition(req.getDisposition()); // FREEZE / RELEASE / LIMIT / SAR
caseEntity.setDispositionNotes(req.getNotes());
caseEntity.setEvidenceAttachments(req.getAttachments());
caseEntity.setState(CaseState.PENDING_REVIEW);
caseRepository.update(caseEntity);
eventPublisher.publishEvent(new DispositionSubmittedEvent(caseEntity));
}
/**
* 主管审批
*/
@Transactional
public void approveDisposition(String caseId, String supervisorId, boolean approved) {
Case caseEntity = caseRepository.findById(caseId)
.orElseThrow(() -> new CaseNotFoundException(caseId));
if (approved) {
caseEntity.setState(CaseState.APPROVED);
caseEntity.setReviewerId(supervisorId);
caseEntity.setReviewedAt(Instant.now());
caseRepository.update(caseEntity);
// 执行处置
executeDisposition(caseEntity);
} else {
// 驳回,退回重新调查
caseEntity.setState(CaseState.REJECTED);
caseEntity.setReviewComments("需补充证据:...");
caseRepository.update(caseEntity);
eventPublisher.publishEvent(new CaseRejectedEvent(caseEntity));
}
}
private void executeDisposition(Case caseEntity) {
switch (caseEntity.getDisposition()) {
case FREEZE -> {
// 调用账户系统冻结
accountService.freezeAccount(caseEntity.getUserId(), caseEntity.getCaseId());
caseEntity.setState(CaseState.RESOLVED);
}
case SAR -> {
// 生成 SAR 报告并上报
sarService.generateAndFile(caseEntity);
caseEntity.setState(CaseState.SAR_FILED);
}
case RELEASE -> {
caseEntity.setState(CaseState.RESOLVED);
}
case LIMIT -> {
accountService.applyWithdrawalLimit(caseEntity.getUserId(), BigDecimal.valueOf(1000));
caseEntity.setState(CaseState.RESOLVED);
}
}
caseEntity.setResolvedAt(Instant.now());
caseRepository.update(caseEntity);
eventPublisher.publishEvent(new CaseResolvedEvent(caseEntity));
}
private void assignAnalyst(Case caseEntity, AssignmentStrategy strategy) {
Analyst analyst = switch (strategy) {
case LOAD_BALANCED -> analystRepository.findLeastLoaded();
case SKILL_MATCHED -> analystRepository.findBySpecialty(caseEntity.getTags());
case ROUND_ROBIN -> analystRepository.findNextInQueue();
};
caseEntity.setAssignedAnalystId(analyst.getAnalystId());
caseEntity.setState(CaseState.ASSIGNED);
caseEntity.setAssignedAt(Instant.now());
caseRepository.update(caseEntity);
}
private CasePriority calculatePriority(List<Alert> alerts) {
boolean hasCritical = alerts.stream()
.anyMatch(a -> a.getSeverity() == AlertSeverity.CRITICAL);
if (hasCritical) return CasePriority.P0;
boolean hasHigh = alerts.stream()
.anyMatch(a -> a.getSeverity() == AlertSeverity.HIGH);
return hasHigh ? CasePriority.P1 : CasePriority.P2;
}
}
/**
* 案件状态枚举
*/
public enum CaseState {
OPEN, // 刚创建
ASSIGNED, // 已分配
UNDER_INVESTIGATION,// 调查中
PENDING_REVIEW, // 待主管审批
APPROVED, // 审批通过
REJECTED, // 驳回(回退至调查)
ESCALATED, // 已升级(高级分析师/法务)
RESOLVED, // 已处置
SAR_FILED, // 已提交 SAR
CLOSED // 归档关闭
}
/**
* 处置类型
*/
public enum Disposition {
FREEZE, // 冻结账户
RELEASE, // 放行/误报
LIMIT, // 限额
SAR // 提交可疑报告
}3.6 存储设计:多模态存储策略
-- ============================================
-- 1. 原始流水:Kafka → S3 (Parquet) + ClickHouse
-- ============================================
-- ClickHouse 本地表(分区按月,按 userId 分片)
CREATE TABLE tx_monitoring.raw_transactions_local ON CLUSTER 'tms_cluster' (
event_id String,
tx_id String,
user_id String,
event_type LowCardinality(String),
timestamp DateTime64(3),
amount Decimal(36, 18),
currency LowCardinality(String),
usd_equivalent Decimal(18, 8),
from_address String,
to_address String,
counterparty_user_id Nullable(String),
counterparty_type LowCardinality(String),
ip_country LowCardinality(String),
ip_risk_score Float32,
device_fingerprint String,
kyc_level UInt8,
account_age_days UInt16,
source_system LowCardinality(String)
) ENGINE = ReplicatedMergeTree('/clickhouse/tables/{shard}/raw_transactions', '{replica}')
PARTITION BY toYYYYMM(timestamp)
ORDER BY (user_id, timestamp)
TTL timestamp + INTERVAL 7 YEAR; -- 监管要求保留 7 年
-- ============================================
-- 2. 聚合特征表:StarRocks(实时预聚合 + 离线补齐)
-- ============================================
CREATE TABLE tms.user_features (
user_id VARCHAR(64) NOT NULL,
feature_date DATE NOT NULL,
withdraw_1h_count BIGINT SUM DEFAULT '0',
withdraw_1h_sum_usd DECIMAL(18,8) SUM DEFAULT '0',
withdraw_24h_count BIGINT SUM DEFAULT '0',
withdraw_24h_sum_usd DECIMAL(18,8) SUM DEFAULT '0',
withdraw_7d_sum_usd DECIMAL(18,8) SUM DEFAULT '0',
trade_30d_count BIGINT SUM DEFAULT '0',
login_unique_countries BIGINT SUM DEFAULT '0',
device_trust_score_avg DOUBLE REPLACE DEFAULT '0.5',
aml_risk_score DOUBLE REPLACE DEFAULT '0.0'
) AGGREGATE KEY(user_id, feature_date)
DISTRIBUTED BY HASH(user_id) BUCKETS 256;
-- ============================================
-- 3. 告警表:MySQL(事务型,支持状态机更新)
-- ============================================
CREATE TABLE tms.alerts (
alert_id VARCHAR(64) PRIMARY KEY,
user_id VARCHAR(64) NOT NULL,
rule_id VARCHAR(64) NOT NULL,
rule_name VARCHAR(256),
severity ENUM('CRITICAL','HIGH','MEDIUM','LOW') NOT NULL,
category VARCHAR(64),
evidence_json JSON,
status ENUM('PENDING','UNDER_REVIEW','RESOLVED','FALSE_POSITIVE') DEFAULT 'PENDING',
sla_deadline TIMESTAMP NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
INDEX idx_user_status (user_id, status),
INDEX idx_sla (sla_deadline, status),
INDEX idx_severity_created (severity, created_at)
) ENGINE=InnoDB;
-- ============================================
-- 4. 案件表:MySQL(工作流核心)
-- ============================================
CREATE TABLE tms.cases (
case_id VARCHAR(64) PRIMARY KEY,
user_id VARCHAR(64) NOT NULL,
priority ENUM('P0','P1','P2','P3') NOT NULL,
state ENUM('OPEN','ASSIGNED','UNDER_INVESTIGATION','PENDING_REVIEW',
'APPROVED','REJECTED','ESCALATED','RESOLVED','SAR_FILED','CLOSED') NOT NULL,
assigned_analyst_id VARCHAR(64),
reviewer_id VARCHAR(64),
disposition ENUM('FREEZE','RELEASE','LIMIT','SAR'),
disposition_notes TEXT,
sar_report_id VARCHAR(64),
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
assigned_at TIMESTAMP NULL,
resolved_at TIMESTAMP NULL,
closed_at TIMESTAMP NULL,
sla_deadline TIMESTAMP NOT NULL,
INDEX idx_user_state (user_id, state),
INDEX idx_analyst_state (assigned_analyst_id, state),
INDEX idx_sla (sla_deadline, state)
) ENGINE=InnoDB;
-- 案件-告警关联表
CREATE TABLE tms.case_alerts (
case_id VARCHAR(64) NOT NULL,
alert_id VARCHAR(64) NOT NULL,
PRIMARY KEY (case_id, alert_id),
FOREIGN KEY (case_id) REFERENCES tms.cases(case_id),
FOREIGN KEY (alert_id) REFERENCES tms.alerts(alert_id)
) ENGINE=InnoDB;
-- ============================================
-- 5. 规则定义表:MySQL + 本地缓存 Caffeine
-- ============================================
CREATE TABLE tms.rules (
rule_id VARCHAR(64) PRIMARY KEY,
version INT NOT NULL DEFAULT 1,
name VARCHAR(256) NOT NULL,
dsl_json JSON NOT NULL,
severity ENUM('CRITICAL','HIGH','MEDIUM','LOW') NOT NULL,
category VARCHAR(64),
status ENUM('DRAFT','ACTIVE','PAUSED','DEPRECATED') DEFAULT 'DRAFT',
created_by VARCHAR(64),
approved_by VARCHAR(64),
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
INDEX idx_status_category (status, category)
) ENGINE=InnoDB;4. 业界案例
4.1 阿里巴巴:蚂蚁集团 AML 智能反洗钱系统
背景:支付宝日均交易笔数超 10 亿,覆盖消费转账、理财、跨境汇款等多业务线,面临央行反洗钱 3 号令的严格合规要求。
架构特点:
- Lambda 架构:实时 Flink 流处理(准实时发现已知模式)+ MaxCompute 离线批处理(深度挖掘未知模式)
- 图神经网络(GNN):构建"账户-设备-IP-银行卡"异构图,识别隐蔽的关联交易环和资金归集网络。相比传统规则,GNN 将可疑团伙识别率提升了 40%
- 智能案件分配:基于分析师历史处置效率和专长标签,使用强化学习动态分配案件,将平均处置时长从 45 分钟降至 18 分钟
- 规则自进化:通过线上 A/B Test 对比新规则与旧规则的误报率/漏报率,自动推荐规则阈值调优建议
踩过的坑:
- 数据倾斜:早期按用户 ID Hash 分区时,出现个别"超级卖家"(日均 10 万笔交易)导致单个 Flink TaskManager OOM。解决:对热点用户启用二级分区(userId + date),并设置单用户最大并发处理上限
- 特征漂移:春节红包活动期间,用户转账频率基线整体上浮 5 倍,导致大量误报。解决:引入"节日模式"动态基线,基于日历事件自动调整统计阈值
4.2 Goldman Sachs:Marquee 交易监控与合规平台
背景:作为全球顶级投行,Goldman 需同时满足 SEC、FCA、FINRA、MAS 等多司法管辖区的监管要求,其交易监控覆盖股票、债券、衍生品、外汇及加密资产。
架构特点:
- 多租户规则引擎:不同业务线(Equities、FICC、Digital Assets)拥有独立的规则 Namespace,但共享底层计算资源。规则版本与业务版本绑定,支持回滚
- 实时 + 回放双模式:除了实时监控外,当新规则上线时,可对过去 90 天的历史交易进行"回放检测",评估规则的命中分布和误报率,避免上线后引发告警风暴
- 自然语言生成(NLG)SAR 报告:当案件被标记为 SAR 时,系统自动提取证据链并生成符合 FinCEN 格式要求的叙事文本(Narrative),将分析师写报告的时间从 2 小时缩短到 10 分钟
- 跨机构情报共享:通过 TRISA(Travel Rule Information Sharing Alliance)协议与其他 VASP 交换 Travel Rule 所需的 KYC 信息,自动校验对手方信息完整性
踩过的坑:
- 跨时区时间戳混乱:一笔涉及伦敦、纽约、新加坡三地交易员的跨境交易,由于各系统使用本地时间记录,导致 CEP 模式匹配时序错乱。解决:强制所有系统使用 UTC 时间,并在 UI 层按用户偏好时区展示
- 监管规则冲突:美国 SEC 要求保留 7 年,欧盟 GDPR 要求"被遗忘权"(用户注销后删除数据)。解决:数据分级脱敏,原始交易保留 7 年但个人身份信息(PII)在注销后 90 天内匿名化
5. 业务场景对照与注意事项
5.1 大型加密货币交易所 大型加密货币交易所 场景映射
大型加密货币交易所作为全球最大加密交易所,其交易监控系统需要覆盖以下业务线的独特风险模式:
5.1.1 现货交易(Spot Trading)
| 风险场景 | 检测规则示例 | 合规映射 |
|---|---|---|
| 刷单/对敲 | 同一用户控制的多个子账户在同一交易对上进行反向高频交易,制造虚假成交量 | 市场操纵监测(Market Abuse) |
| 价格操纵 | 大额订单在盘口快速挂撤(Spoofing),诱导其他交易者跟单 | MiFID II / SEC Rule 15c3-5 |
| 内幕交易 | 上币公告前,关联账户异常集中买入待上线代币 | 内部监控系统交叉比对员工/关联方名单 |
QPS 与延迟:
- 现货撮合峰值 ~200K TPS(含订单创建、修改、撤销、成交)
- TMS 无需同步阻塞,但需在 5min 内检测到异常成交模式并触发分析师审核
5.1.2 合约交易(Futures / Margin)
| 风险场景 | 检测规则示例 | 合规映射 |
|---|---|---|
| 操纵爆仓 | 大资金账户在低流动性时段通过现货+合约联动拉盘/砸盘,定向爆对手仓位 | 市场操纵 + 客户投诉关联 |
| 过度杠杆 | 用户风险率持续 < 110% 且频繁追加保证金,疑似赌博行为 | 负责任交易(Responsible Trading)监控 |
| 老鼠仓 | 内部人员提前开仓,利用职务信息牟利 | 员工交易监控 + 持仓申报 |
5.1.3 P2P 法币交易
| 风险场景 | 检测规则示例 | 合规映射 |
|---|---|---|
| 银行卡冻结链 | 多名买方用户向同一卖方支付后,银行卡被异地公安冻结 | 涉赌涉诈资金链追踪 |
| 价格偏离 | 广告价格显著偏离市场汇率(> 5%),疑似洗钱通道 | 价格异常监控 |
| 高频对手方轮换 | 同一卖方在 1h 内与 > 10 个不同买方成交,且无历史交易关系 | Structuring 行为 |
5.1.4 出金(Withdrawal)—— TMS 最核心的监控场景
| 风险场景 | 检测规则示例 | 合规映射 |
|---|---|---|
| 制裁地址 | 出金目标地址命中 OFAC SDN List 或 Chainalysis 已知非法地址 | Travel Rule / OFAC 合规 |
| 混币器交互 | 出金后 3 跳内经过 Tornado Cash、Sinbad 等混币合约 | FATF R.15 VASP 义务 |
| Structuring | 同一用户 24h 内多笔出金,每笔略低于申报阈值(如 1000 USD 等值) | BSA / AML structuring 法规 |
| 不可能旅行 | 用户 1h 前在香港登录,现在出金请求来自美国 IP | 账户盗用 / 凭证泄露 |
QPS 与延迟:
- 出金请求峰值 ~5K TPS
- TMS 准实时检测延迟 < 3min(以便在区块链确认前拦截可疑出金)
- Travel Rule 信息交换需在出金前完成:> 1000 USD 等值出金至外部 VASP 时,必须先获取并校验对手方 KYC 信息
5.1.5 入金(Deposit)与 Swap
| 风险场景 | 检测规则示例 |
|---|---|
| 黑钱入金 | 链上资金来源包含已知黑客事件地址(如 Ronin Bridge Hack) |
| Swap 洗钱 | 用户在平台内频繁 Swap 多种小币种,试图切断链上追踪 |
5.2 监管合规映射
| 监管框架 | 核心要求 | TMS 实现 |
|---|---|---|
| FATF R.16 (Travel Rule) | >= 1000 USD 的 VASP 间转账需交换 Originator + Beneficiary 信息 | Travel Rule Gateway:出金前校验对手方 VASP 是否支持 Travel Rule;若支持则先完成信息交换再放行 |
| FATF R.15 | VASP 需建立有效的 AML/CFT 体系,包括客户尽职调查、交易监控、可疑报告 | TMS 全量覆盖 + SAR 自动生成 + 审计日志 7 年留存 |
| 美国 BSA | 金融机构需提交 Currency Transaction Report (CTR) 和 Suspicious Activity Report (SAR) | CTR 自动生成(单笔 > 10000 USD 现金等值交易);SAR 工作流集成 |
| 欧盟 5AMLD | 加密资产服务提供商(CASPs)纳入 AMLD 管辖,需进行客户身份验证和交易监控 | KYC 等级与交易限额联动;高风险国家增强尽调(EDD) |
| 香港 SFC | 持牌虚拟资产交易平台需建立市场操纵监控和投资者保障机制 | 现货/合约市场滥用规则;投资者赔偿基金关联 |
5.3 常见误区 vs 正确做法
| ❌ 常见误区 | ✅ 正确做法 |
|---|---|
| TMS 可以替代实时风控引擎 | 两者互补:实时引擎负责毫秒级拦截,TMS 负责跨时间窗口的深度分析与合规报告 |
| 规则越多越好 | 规则过多会导致告警风暴和分析师疲劳。应建立规则生命周期管理:上线 → 监控误报率 → 调优/下线 |
| 所有交易都走准实时检测 | 根据业务风险分级:出金/P2P 走准实时(< 3min),现货成交走批量(T+1),降低成本 |
| 案件分配给固定分析师 | 应根据负载、专长、历史效能动态分配,并设置 SLA 自动升级 |
| 误报案件直接关闭即可 | 误报需标注原因并回流给规则/模型团队,用于规则调优和模型重训练,形成闭环 |
| 只保存命中告警的交易 | 监管要求保存全量交易(含已放行),以备事后审计和回溯调查 |
6. FAQ 与高频追问
Q1: TMS 和实时风控引擎的关系是什么?为什么需要两套系统而不是一套?
A: 两者是互补关系,而非替代关系。
- 实时风控引擎是"急诊分诊":必须在 50ms 内对单笔交易做出 PASS/REJECT 决策,因此只能使用简单的硬规则(黑名单、阈值)和轻量模型。它假设"看到的数据有限,时间极其紧迫"。
- TMS是"疑难杂症会诊":允许几分钟到几小时的延迟,因此可以加载用户过去数月的历史行为、关联网络、离线画像,运行复杂的 CEP 模式和 GNN 图算法。它假设"时间换精度"。
为什么不能合并为一套?
- 延迟矛盾:TMS 需要的跨窗口聚合和图谱计算无法在 50ms 内完成
- 可用性矛盾:实时引擎要求 99.99% 可用性,需极度精简;TMS 可以容忍 99.95%,允许更复杂的依赖
- 职责矛盾:实时引擎对用户体验负责(误拦截直接影响交易);TMS 对监管负责(漏报可能导致天价罚款)
两者联动:实时引擎将"可疑但不确定"的交易标记为 REVIEW,送入 TMS 深度分析;TMS 发现的最新风险模式通过规则下发通道回流到实时引擎,提升前端拦截能力。
Q2: 如何防止 TMS 本身成为系统瓶颈?当交易峰值突然飙升 5 倍时,如何保证检测不延迟?
A: 弹性扩展 + 分级降级 + 背压机制。
- 水平扩展:Flink 作业的并行度与 Kafka 分区数对齐(如 512 分区 → 512 并行 TaskManager)。通过 Kubernetes HPA 基于 CPU/消费延迟自动扩容
- 分级降级:
- 正常态:全量规则运行 + 全量特征加载
- 高负载态:暂停 LOW 优先级规则的离线批处理,保留 CRITICAL/HIGH 规则
- 过载态:仅运行制裁名单命中等硬规则,其他延迟到夜间低峰期补跑
- 背压(Backpressure):当 Flink Sink(写入告警库)变慢时,Flink 自动反压至 Source,降低 Kafka 消费速率,避免内存溢出。同时触发告警通知运维
- 计算与存储分离:实时检测使用内存计算(Flink State),结果异步写入数据库。即使数据库抖动,检测流不中断
Q3: 如果一笔交易被 TMS 判定为可疑,但区块链上已经确认了(出金已完成),怎么办?
A: 这是加密交易所 TMS 的核心痛点,因为链上转账不可逆。
事前预防(Primary Defense):
- 出金流程设计为"审批后出金"而非"先出金后监控":TMS 准实时检测在核心系统的"待审核队列"中完成,未通过检测的出金不会进入区块链广播阶段
- 对于高风险用户(新注册、KYC 低等级、高风险国家),强制引入"人工审核"环节,TMS 检测完成且分析师放行后才广播交易
事后补救(Secondary Defense):
- 若发现已确认交易涉及制裁地址或黑客地址,立即将目标地址加入全局黑名单,后续任何向该地址的出金直接拒绝
- 若用户仍在平台有未出金资产,启动账户冻结和资金追回流程(如通过链上分析追踪资金流向,配合执法机关)
- 生成 SAR 并在法定时限内(通常 30 天)上报监管机构
架构保障:
- 出金核心系统与 TMS 通过 Kafka 解耦,TMS 的处理延迟不应影响出金 API 的同步响应(用户看到"提现申请已提交"),但核心系统持有"最终放行权"
Q4: Travel Rule 在 TMS 中如何落地实现?涉及哪些技术挑战?
A: Travel Rule 是 FATF R.16 对 VASP 的核心要求:当用户向另一个 VASP 地址转账 >= 1000 USD 等值时, originating VASP 必须向 beneficiary VASP 传输 Originators 和 Beneficiaries 的 KYC 信息。
系统架构:
用户发起出金 → 核心系统
↓
Travel Rule Gateway 拦截
↓
1. 金额 >= 1000 USD?
└─ 否 → 正常出金流程
└─ 是 → 判断对手方地址归属
↓
2. 对手方是否为已知 VASP 地址?
└─ 否(未知钱包)→ 记录 Travel Rule Exemption,放行
└─ 是(VASP)→ 查询对手方 Travel Rule 支持状态
↓
3. 对手方是否支持 Travel Rule(如通过 TRISA / Sygna Bridge / OpenVASP)?
└─ 否 → 根据当地法规:可能拒绝出金或要求用户确认风险
└─ 是 → 发起加密安全信息交换
↓
4. 信息交换成功?
└─ 否 → 出金挂起,通知用户补充信息
└─ 是 → TMS 记录交换日志( Originator/Beneficiary 信息哈希),放行出金
技术挑战:
- VASP 发现:如何判定一个链上地址属于哪个 VASP?依赖 Chainalysis/Elliptic 等链上情报服务商的地址标签库,覆盖率并非 100%
- 互操作性:不同 VASP 可能使用不同的 Travel Rule 协议(TRISA、Sygna、OpenVASP、Notabene),需要协议适配层
- 隐私与合规平衡:传输的 KYC 信息需端到端加密(如使用 TRISA 的 mTLS + 加密信封),平台自身也不能明文存储对手方用户的 PII
- 失败回退:若对手方 VASP 网关宕机,需有超时机制(如 24h)和回退策略(拒绝出金或挂起待处理)
Q5: 如何度量 TMS 的效能?有哪些关键指标(KPI)?
A: TMS 的效能需从"检测效果"、"运营效率"、"合规质量"三个维度度量:
一、检测效果指标
| 指标 | 计算方式 | 健康阈值 |
|---|---|---|
| SAR 转化率 | 提交 SAR 的案件数 / 总创建案件数 | 5% ~ 15%(过低 = 漏报,过高 = 误报) |
| 误报率(FPR) | 最终标记为 FALSE_POSITIVE 的 Alert 数 / 总 Alert 数 | < 80%(逐步优化至 < 60%) |
| 漏报发现率 | 事后审计发现的漏报案件数 / 实际风险案件数 | 尽量接近 0(通过回溯检测评估) |
| 规则命中率分布 | 每条规则的命中次数 / 总命中次数 | 避免单条规则垄断 > 50% 命中 |
二、运营效率指标
| 指标 | 计算方式 | 健康阈值 |
|---|---|---|
| 平均处置时长(MTTR) | 案件创建到结案的时间中位数 | P0 < 30min, P1 < 4h, P2 < 24h |
| SLA 达成率 | SLA 内结案的案件数 / 总案件数 | > 95% |
| 分析师人均日产能 | 结案数 / 分析师数 / 工作日 | 根据复杂度,目标 15~30 件/人/天 |
三、合规质量指标
| 指标 | 计算方式 | 健康阈值 |
|---|---|---|
| SAR 及时提交率 | 法定期限内提交的 SAR 数 / 应提交 SAR 数 | 100%(零容忍) |
| 监管问询响应时间 | 收到监管问询到提交完整证据包的时间 | < 72h |
| 审计追踪完整性 | 有完整操作日志的案件数 / 总案件数 | 100% |
持续优化机制:
- 每周召开"告警质量 Review":分析 Top 10 误报规则,调优阈值或下线
- 每月"SAR 回头看":随机抽样已结案件,由高级分析师独立复核,评估漏报
- 每季度"模型重训练":将最新标注数据(True Positive / False Positive)回流给 ML 团队,更新异常检测模型
Q6(追问): 如何处理 TMS 的"冷启动"问题——新用户没有历史行为基线,怎么做异常检测?
A: 新用户(< 7 天注册)是 TMS 的检测盲区,需采用多层策略:
- 群体基线替代个体基线:用"同 KYC 等级 + 同注册渠道 + 同地理区域"的用户群体统计特征作为临时基线。例如:新注册用户 7 天内平均出金金额为 200 USD,若某用户首日出金 10000 USD,则触发偏离检测
- 加速观察期:新用户前 30 天进入"增强监控期",规则阈值收紧(如正常用户 1h 提现上限为 100K USD,新用户为 5K USD)
- 外部数据补全:对接第三方征信/情报服务商(如 Chainalysis KYT、Coinfirm),获取该用户链上地址的历史风险评分,作为冷启动特征
- 设备/网络关联:即使用户是新的,若其设备指纹或 IP 与已知风险用户重合,可直接引用关联实体的风险标签
- 保守策略:新用户的大额出金(如 > 1000 USD)在 TMS 中默认赋予更高初始权重,等待积累足够数据后再调降
Q7(追问): 如果监管要求你解释"为什么这个模型认为这笔交易可疑",黑盒模型如何应对?
A: 金融风控领域对模型可解释性(XAI)有刚性需求,特别是欧盟 GDPR 的"解释权"(Right to Explanation)。
技术方案:
- 模型选型优先可解释性:
- 规则引擎:天然可解释(命中了哪条规则,条件是什么)
- 树模型(XGBoost/LightGBM):通过 SHAP 值解释每个特征对最终评分的贡献
- 避免纯黑盒深度神经网络作为唯一决策依据,或将其仅作为辅助参考
- SHAP / LIME 集成:模型输出分数时,同步输出 Top 5 正向/负向特征贡献。例如:"可疑原因:出金金额为用户历史均值的 15 倍(+0.25),目标地址为首次出现(+0.18),IP 位于高风险国家(+0.15)"
- 决策分层:高置信度(> 0.95)的模型输出可自动决策;中等置信度需叠加规则解释;低置信度不单独产出告警
- 证据链固化:无论模型还是规则触发,最终写入 Alert 的 evidence_json 必须包含"触发原因的自然语言描述",供分析师和监管审查