面试系统设计:交易监测

通识对照:实时风控决策路径:同步拦截窗与异步监测

面试系统设计:交易监测

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 / REVIEWAlert(告警)→ Case(案件)→ SAR(可疑报告)

1.2 核心概念词典

术语英文定义
可疑交易Suspicious Transaction金额、频率、对手方、路径等维度偏离用户历史基线或监管阈值的交易
告警(Alert)Alert规则/模型命中后生成的待审核风险信号,含风险等级、命中规则、证据链
案件(Case)Case由一个或多个关联 Alert 聚合而成的调查单元,含工作流状态
SAR/STRSuspicious Activity/Transaction Report向监管机构(FinCEN、FCA、香港 SFC 等)提交的可疑活动报告
Travel RuleTravel RuleFATF Recommendation 16,要求 VASP 间传输 >= 1000 USD 的加密资产时交换 KYC 信息
CEPComplex Event Processing复杂事件处理,用于识别跨时间窗口的交易序列模式
Rule DSLDomain Specific Language面向风控运营的规则声明语言,支持非研发人员配置检测逻辑

1.3 类比理解:TMS = 医院的"疑难杂症会诊中心"

类比:医院会诊中心 vs 交易监控系统

  • 实时风控引擎 = 急诊室分诊台:病人(交易)来了,快速判断"生死"(拦截/放行),处理时间以分钟计
  • TMS 数据采集层 = 全院病历系统:汇集门诊、住院、检验、影像等全量数据(交易流水、用户行为、KYC、设备指纹)
  • TMS 异常检测层 = AI 辅助诊断系统 + 专家会诊规则:"这个病人过去 3 个月多次轻微头痛(小额试探),今天突然剧烈头痛伴呕吐(大额出金),高度怀疑脑出血(洗钱)"
  • TMS 告警分级 = 病情分级(病危/病重/一般):红色(1 分钟内通知主任)、黄色(30 分钟内通知主治医师)、蓝色(每日汇总查房)
  • TMS 案件管理 = 疑难病例档案:从入院(创建案件)→ 主治医师接手(分配)→ 检查化验(调查取证)→ 确诊出院(结案上报)→ 归档(合规留痕)
  • SAR 报告 = 向 CDC(疾控中心)上报的传染病报告:有法定格式、法定时限、法定责任

1.4 为什么需要 TMS(解决了什么问题)

  1. 实时引擎的"近视"问题:实时引擎只能看到"当前这一笔",无法识别"过去 30 天内 20 笔小额充值后突然大额出金"的 Structuring( structuring, structuring)行为
  2. 监管合规刚性:FATF、欧盟 5AMLD、美国 BSA 要求交易所必须建立"有效的交易监控体系"并定期提交 SAR/STR
  3. 模型冷启动与未知风险:新出现的洗钱手法(如 2022 年 Tornado Cash 混币)无法被实时硬规则覆盖,需要离线图谱分析和行为基线偏离检测
  4. 审计与举证:当监管机构问询"你们为什么冻结这个账户"时,需要完整的证据链(命中规则、关联交易、模型评分、处置记录)

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准实时用于快速冻结,离线用于深度挖掘
告警处理 QPS10K+峰值告警生成速率
案件查询 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 倍、新设备首次大额出金
LOWT+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;         // 环境变量,如当前监管政策开关
    }
}
/**
 * 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 号令的严格合规要求。

架构特点:

  1. Lambda 架构:实时 Flink 流处理(准实时发现已知模式)+ MaxCompute 离线批处理(深度挖掘未知模式)
  2. 图神经网络(GNN):构建"账户-设备-IP-银行卡"异构图,识别隐蔽的关联交易环和资金归集网络。相比传统规则,GNN 将可疑团伙识别率提升了 40%
  3. 智能案件分配:基于分析师历史处置效率和专长标签,使用强化学习动态分配案件,将平均处置时长从 45 分钟降至 18 分钟
  4. 规则自进化:通过线上 A/B Test 对比新规则与旧规则的误报率/漏报率,自动推荐规则阈值调优建议

踩过的坑:

  • 数据倾斜:早期按用户 ID Hash 分区时,出现个别"超级卖家"(日均 10 万笔交易)导致单个 Flink TaskManager OOM。解决:对热点用户启用二级分区(userId + date),并设置单用户最大并发处理上限
  • 特征漂移:春节红包活动期间,用户转账频率基线整体上浮 5 倍,导致大量误报。解决:引入"节日模式"动态基线,基于日历事件自动调整统计阈值

4.2 Goldman Sachs:Marquee 交易监控与合规平台

背景:作为全球顶级投行,Goldman 需同时满足 SEC、FCA、FINRA、MAS 等多司法管辖区的监管要求,其交易监控覆盖股票、债券、衍生品、外汇及加密资产。

架构特点:

  1. 多租户规则引擎:不同业务线(Equities、FICC、Digital Assets)拥有独立的规则 Namespace,但共享底层计算资源。规则版本与业务版本绑定,支持回滚
  2. 实时 + 回放双模式:除了实时监控外,当新规则上线时,可对过去 90 天的历史交易进行"回放检测",评估规则的命中分布和误报率,避免上线后引发告警风暴
  3. 自然语言生成(NLG)SAR 报告:当案件被标记为 SAR 时,系统自动提取证据链并生成符合 FinCEN 格式要求的叙事文本(Narrative),将分析师写报告的时间从 2 小时缩短到 10 分钟
  4. 跨机构情报共享:通过 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.15VASP 需建立有效的 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 图算法。它假设"时间换精度"。

为什么不能合并为一套?

  1. 延迟矛盾:TMS 需要的跨窗口聚合和图谱计算无法在 50ms 内完成
  2. 可用性矛盾:实时引擎要求 99.99% 可用性,需极度精简;TMS 可以容忍 99.95%,允许更复杂的依赖
  3. 职责矛盾:实时引擎对用户体验负责(误拦截直接影响交易);TMS 对监管负责(漏报可能导致天价罚款)

两者联动:实时引擎将"可疑但不确定"的交易标记为 REVIEW,送入 TMS 深度分析;TMS 发现的最新风险模式通过规则下发通道回流到实时引擎,提升前端拦截能力。

Q2: 如何防止 TMS 本身成为系统瓶颈?当交易峰值突然飙升 5 倍时,如何保证检测不延迟?

A: 弹性扩展 + 分级降级 + 背压机制。

  1. 水平扩展:Flink 作业的并行度与 Kafka 分区数对齐(如 512 分区 → 512 并行 TaskManager)。通过 Kubernetes HPA 基于 CPU/消费延迟自动扩容
  2. 分级降级:
    • 正常态:全量规则运行 + 全量特征加载
    • 高负载态:暂停 LOW 优先级规则的离线批处理,保留 CRITICAL/HIGH 规则
    • 过载态:仅运行制裁名单命中等硬规则,其他延迟到夜间低峰期补跑
  3. 背压(Backpressure):当 Flink Sink(写入告警库)变慢时,Flink 自动反压至 Source,降低 Kafka 消费速率,避免内存溢出。同时触发告警通知运维
  4. 计算与存储分离:实时检测使用内存计算(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 信息哈希),放行出金

技术挑战:

  1. VASP 发现:如何判定一个链上地址属于哪个 VASP?依赖 Chainalysis/Elliptic 等链上情报服务商的地址标签库,覆盖率并非 100%
  2. 互操作性:不同 VASP 可能使用不同的 Travel Rule 协议(TRISA、Sygna、OpenVASP、Notabene),需要协议适配层
  3. 隐私与合规平衡:传输的 KYC 信息需端到端加密(如使用 TRISA 的 mTLS + 加密信封),平台自身也不能明文存储对手方用户的 PII
  4. 失败回退:若对手方 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 的检测盲区,需采用多层策略:

  1. 群体基线替代个体基线:用"同 KYC 等级 + 同注册渠道 + 同地理区域"的用户群体统计特征作为临时基线。例如:新注册用户 7 天内平均出金金额为 200 USD,若某用户首日出金 10000 USD,则触发偏离检测
  2. 加速观察期:新用户前 30 天进入"增强监控期",规则阈值收紧(如正常用户 1h 提现上限为 100K USD,新用户为 5K USD)
  3. 外部数据补全:对接第三方征信/情报服务商(如 Chainalysis KYT、Coinfirm),获取该用户链上地址的历史风险评分,作为冷启动特征
  4. 设备/网络关联:即使用户是新的,若其设备指纹或 IP 与已知风险用户重合,可直接引用关联实体的风险标签
  5. 保守策略:新用户的大额出金(如 > 1000 USD)在 TMS 中默认赋予更高初始权重,等待积累足够数据后再调降

Q7(追问): 如果监管要求你解释"为什么这个模型认为这笔交易可疑",黑盒模型如何应对?

A: 金融风控领域对模型可解释性(XAI)有刚性需求,特别是欧盟 GDPR 的"解释权"(Right to Explanation)。

技术方案:

  1. 模型选型优先可解释性:
    • 规则引擎:天然可解释(命中了哪条规则,条件是什么)
    • 树模型(XGBoost/LightGBM):通过 SHAP 值解释每个特征对最终评分的贡献
    • 避免纯黑盒深度神经网络作为唯一决策依据,或将其仅作为辅助参考
  2. SHAP / LIME 集成:模型输出分数时,同步输出 Top 5 正向/负向特征贡献。例如:"可疑原因:出金金额为用户历史均值的 15 倍(+0.25),目标地址为首次出现(+0.18),IP 位于高风险国家(+0.15)"
  3. 决策分层:高置信度(> 0.95)的模型输出可自动决策;中等置信度需叠加规则解释;低置信度不单独产出告警
  4. 证据链固化:无论模型还是规则触发,最终写入 Alert 的 evidence_json 必须包含"触发原因的自然语言描述",供分析师和监管审查