@clonegod/ttd-sol-common 2.0.75 → 2.0.76

package/dist/common/subscribe_account_update.d.ts

@@ -1,4 +1,4 @@
 import { StandardPoolInfoType } from "@clonegod/ttd-core";
 import { DEX_ID } from "@clonegod/ttd-core/dist";
-import { SolanaPoolAccountUpdateEventData } from "../types";
-export declare function subscribe_pool_account_update(dex_id: DEX_ID, pool_list: StandardPoolInfoType[], callback: (eventData: SolanaPoolAccountUpdateEventData) => void): void;
+import { SolanaPoolAccountUpdateEventData, SolanaSwapVerifyEventData } from "../types";
+export declare function subscribe_pool_account_update(dex_id: DEX_ID, pool_list: StandardPoolInfoType[], callback: (eventData: SolanaPoolAccountUpdateEventData) => void, onSwapVerify?: (eventData: SolanaSwapVerifyEventData) => void): void;

package/dist/common/subscribe_account_update.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.subscribe_pool_account_update = subscribe_pool_account_update;
 const dist_1 = require("@clonegod/ttd-core/dist");
-function subscribe_pool_account_update(dex_id, pool_list, callback) {
+function subscribe_pool_account_update(dex_id, pool_list, callback, onSwapVerify) {
     const port = dist_1.SERVICE_PORT.STREAM_QUOTE_WS;
     const ws_url = `ws://127.0.0.1:${port}`;
     const ws_client = new dist_1.WebSocketClient(ws_url);
@@ -16,11 +16,16 @@ function subscribe_pool_account_update(dex_id, pool_list, callback) {
             (0, dist_1.log_info)(`subscribe_pool_account_update: ACK ${eventData.ws_id || eventData.pool_address || ''}`);
             return;
         }
-        if (!eventData.data) {
+        if (eventData.kind === 'swap_verify') {
+            onSwapVerify?.(eventData);
+            return;
+        }
+        const accountData = eventData;
+        if (!accountData.data) {
             (0, dist_1.log_warn)(`subscribe_pool_account_update: no data`, eventData);
             return;
         }
-        callback(eventData);
+        callback(accountData);
     }));
     ws_client.connect();
 }

package/dist/quote/abstract_dex_quote.d.ts

@@ -1,7 +1,7 @@
 import { AppConfig, QuoteDepthOutput, QuoteResultType, StandardPoolInfoType } from '@clonegod/ttd-core/dist';
 import { SolanaChainOps } from './chain_ops';
 import { SolPoolEvent } from './pool_event';
-import { QuotePriceVerify, CheckSwapParams } from './verify/quote_price_verify';
+import { QuotePriceVerify } from './verify/quote_price_verify';
 import { QuoteTrace } from './quote_trace';
 export type ConsistencyPolicy = 'snapshot' | 'slot-gate' | 'tx-driven';
 export interface PoolInitSummary {
@@ -50,7 +50,7 @@ export declare abstract class AbstractDexQuote<C extends SolanaChainOps = Solana
     protected calculateDepth(_poolInfo: StandardPoolInfoType, _poolAddress: string, _priceMap: Map<string, {
         price: string;
     } | undefined>): Promise<QuoteDepthOutput | undefined>;
-    protected buildSwapVerify(_poolInfo: StandardPoolInfoType, _evt: SolPoolEvent): CheckSwapParams | null;
+    protected readonly feeInVault: boolean;
     protected isStateConsistentForQuote(_poolInfo: StandardPoolInfoType): boolean;
     protected accountSlots: Map<string, number>;
     protected recordAccountSlot(accountAddr: string, slot: number): void;
@@ -58,6 +58,7 @@ export declare abstract class AbstractDexQuote<C extends SolanaChainOps = Solana
     protected beforeLoadPools(): Promise<void>;
     protected getQuoteAmountUsd(poolInfo: StandardPoolInfoType): number;
     private registerEventHandlers;
+    private handleSwapVerify;
     private assertValidBlockNumber;
     private isStaleUpdate;
     private shouldApplyState;

package/dist/quote/abstract_dex_quote.js

@@ -15,13 +15,13 @@ class AbstractDexQuote {
         this.latestBlockSlot = 0;
         this.MIN_QUOTE_INTERVAL_MS = Math.max(3000, parseInt(process.env.MIN_QUOTE_INTERVAL_MS || '10000', 10) || 10000);
         this.consistencyPolicy = 'snapshot';
+        this.feeInVault = true;
         this.accountSlots = new Map();
         this.appConfig = appConfig;
         this.chain = chain;
     }
     async refreshStateFromEvent(_poolInfo, _evt) { }
     async calculateDepth(_poolInfo, _poolAddress, _priceMap) { return undefined; }
-    buildSwapVerify(_poolInfo, _evt) { return null; }
     isStateConsistentForQuote(_poolInfo) { return true; }
     recordAccountSlot(accountAddr, slot) {
         this.accountSlots.set(accountAddr, slot);
@@ -50,12 +50,34 @@ class AbstractDexQuote {
     registerEventHandlers() {
         this.chain.subscribeNewBlock((raw) => this.handleBlockUpdateEvent(raw));
         this.chain.subscribePoolEvents(this.dexId, Array.from(this.poolInfoMap.values()), async (evt) => {
-            const { bundle, verifyLog } = await this.calculateQuote(evt);
+            const bundle = await this.calculateQuote(evt);
             if (bundle)
                 this.publishQuote(bundle);
-            if (verifyLog)
-                (0, dist_1.log_info)(verifyLog);
-        });
+        }, (sv) => this.handleSwapVerify(sv));
+    }
+    handleSwapVerify(sv) {
+        const poolInfo = this.poolInfoMap.get(sv.pool_address);
+        if (!poolInfo)
+            return;
+        const params = {
+            poolAddress: poolInfo.pool_address,
+            poolName: poolInfo.pool_name,
+            blockNumber: Number(sv.slot),
+            txHash: sv.tx_hash || 'swap',
+            amount0: sv.amount0,
+            amount1: sv.amount1,
+            token0Address: poolInfo.tokenA?.address,
+            token1Address: poolInfo.tokenB?.address,
+            token0Decimals: Number(poolInfo.tokenA?.decimals ?? 0),
+            token1Decimals: Number(poolInfo.tokenB?.decimals ?? 0),
+            poolInfo: { tokenA: poolInfo.tokenA, tokenB: poolInfo.tokenB, quote_token: poolInfo.quote_token },
+            swapperDeltaConvention: false,
+            feeExclusiveExec: !this.feeInVault,
+            feeRateBps: poolInfo.fee_rate,
+        };
+        const verifyLog = this.quotePriceVerify.checkSwap(params);
+        if (verifyLog)
+            (0, dist_1.log_info)(verifyLog);
     }
     assertValidBlockNumber(blockNumber, ctx) {
         if (!Number.isInteger(blockNumber) || blockNumber <= 0) {
@@ -76,7 +98,7 @@ class AbstractDexQuote {
     async handleBlockUpdateEvent(eventData) {
         const parsed = JSON.parse(eventData);
         const slot = Number(parsed.slot);
-        const blockTime = Number(parsed.blockTime);
+        const streamRecvMs = Number(parsed.recvBlockTime) || Date.now();
         this.assertValidBlockNumber(slot, `${this.dexId} block-event`);
         this.latestBlockSlot = slot;
         for (const poolInfo of this.poolInfoMap.values()) {
@@ -85,7 +107,7 @@ class AbstractDexQuote {
             const last = this.poolLastQuoteTimeMap.get(poolAddress) || 0;
             if (now - last >= this.MIN_QUOTE_INTERVAL_MS) {
                 this.poolLastQuoteTimeMap.set(poolAddress, now);
-                const result = await this.calculateQuoteForPool(poolInfo, blockTime, slot);
+                const result = await this.calculateQuoteForPool(poolInfo, streamRecvMs, slot);
                 if (result)
                     this.publishQuote(result);
             }
@@ -94,23 +116,18 @@ class AbstractDexQuote {
     async calculateQuote(evt) {
         const poolInfo = this.poolInfoMap.get(evt.pool_address);
         if (!poolInfo)
-            return { bundle: null };
+            return null;
         this.assertValidBlockNumber(evt.blockNumber, `${this.dexId} ${poolInfo.pool_name} account-update`);
-        let verifyLog;
-        const v = this.buildSwapVerify(poolInfo, evt);
-        if (v)
-            verifyLog = this.quotePriceVerify.checkSwap(v) || undefined;
         const hasWv = Number.isInteger(evt.writeVersion);
         const skipApply = hasWv && !this.shouldApplyState(evt.pool_address, evt.blockNumber, evt.writeVersion);
         if (!skipApply)
             await this.refreshStateFromEvent(poolInfo, evt);
         if (hasWv && this.isStaleUpdate(evt.pool_address, evt.blockNumber, evt.writeVersion))
-            return { bundle: null, verifyLog };
+            return null;
         if (this.consistencyPolicy === 'slot-gate' && !this.isStateConsistentForQuote(poolInfo)) {
-            return { bundle: null, verifyLog };
+            return null;
         }
-        const bundle = await this.calculateQuoteForPool(poolInfo, evt.blockTime, evt.blockNumber, evt);
-        return { bundle, verifyLog };
+        return this.calculateQuoteForPool(poolInfo, evt.blockTime, evt.blockNumber, evt);
     }
     async calculateQuoteForPool(poolInfo, streamTimestamp, blockNumber, evt) {
         const { pool_address } = poolInfo;

package/dist/quote/chain_ops.d.ts

@@ -1,5 +1,6 @@
 import { AppConfig, CHAIN_ID, StandardPoolInfoType } from '@clonegod/ttd-core/dist';
 import { Connection } from '@solana/web3.js';
+import { SolanaSwapVerifyEventData } from '../types';
 import { SolPoolEvent } from './pool_event';
 import { TokenPriceCache } from './pricing/token_price_cache';
 export declare class SolanaChainOps {
@@ -14,5 +15,5 @@ export declare class SolanaChainOps {
         price: string;
     } | undefined>>;
     subscribeNewBlock(handler: (raw: string) => void): void;
-    subscribePoolEvents(dexId: string, pools: StandardPoolInfoType[], handler: (evt: SolPoolEvent) => void): void;
+    subscribePoolEvents(dexId: string, pools: StandardPoolInfoType[], handler: (evt: SolPoolEvent) => void, onSwapVerify?: (evt: SolanaSwapVerifyEventData) => void): void;
 }

package/dist/quote/chain_ops.js

@@ -48,7 +48,7 @@ class SolanaChainOps {
     subscribeNewBlock(handler) {
         this.appConfig.arb_event_subscriber.subscribe_new_block(this.chainId, handler);
     }
-    subscribePoolEvents(dexId, pools, handler) {
+    subscribePoolEvents(dexId, pools, handler, onSwapVerify) {
         const dex = dexId.toUpperCase();
         const poolSet = new Set(pools.map(p => p.pool_address));
         (0, subscribe_account_update_1.subscribe_pool_account_update)(dex, pools, (data) => {
@@ -60,7 +60,18 @@ class SolanaChainOps {
             catch (e) {
                 (0, dist_1.log_warn)(`[SolanaChainOps] bad pool account update`, data);
             }
-        });
+        }, onSwapVerify
+            ? (sv) => {
+                try {
+                    if (!poolSet.has(sv.pool_address))
+                        return;
+                    onSwapVerify(sv);
+                }
+                catch (e) {
+                    (0, dist_1.log_warn)(`[SolanaChainOps] bad swap-verify event`, sv);
+                }
+            }
+            : undefined);
     }
 }
 exports.SolanaChainOps = SolanaChainOps;

package/dist/quote/pool_subscription_registry.js

@@ -46,7 +46,11 @@ async function unregisterPoolSubscriptions(appConfig, quote_app_id) {
     }
 }
 async function attachPoolSubscriptionLifecycle(appConfig, pools) {
-    const quote_app_id = String(appConfig.env_args.app_name || '').toLowerCase() || 'sol-quote';
+    const quote_app_id = process.env.name || String(appConfig.env_args.app_name || '');
+    if (!quote_app_id) {
+        throw new Error('[pool/subscriptions] 无法确定 quote_app_id：process.env.name(PM2 进程名) 与 APP_NAME 均为空。'
+            + '询价进程必须由 PM2/trade-mgt 以确定进程名启动，否则订阅会被 reconcile 当孤儿清除。');
+    }
     await registerPoolSubscriptions(appConfig, pools, quote_app_id);
     let cleaned = false;
     const cleanup = async (sig) => {

package/dist/quote/verify/quote_price_verify.d.ts

@@ -16,6 +16,8 @@ export interface CheckSwapParams {
         quote_token: string;
     };
     swapperDeltaConvention?: boolean;
+    feeExclusiveExec?: boolean;
+    feeRateBps?: number;
 }
 export declare class QuotePriceVerify {
     private quoteCache;

package/dist/quote/verify/quote_price_verify.js

@@ -47,6 +47,11 @@ function pickMatchingTier(tiers, actualAmountIn) {
     }
     return { tier: top, mode: 'extrapolated_high', lo_pct: top.pct, hi_pct: null };
 }
+function stripFeeExclusive(refPrice, isBuy, r) {
+    if (!(r > 0) || r >= 1)
+        return refPrice;
+    return isBuy ? refPrice * (1 - r) : refPrice / (1 - r);
+}
 class QuotePriceVerify {
     constructor() {
         this.quoteCache = new Map();
@@ -109,6 +114,9 @@ class QuotePriceVerify {
                 if (!match)
                     continue;
                 refPrice = match.tier.price;
+                if (params.feeExclusiveExec && match.tier.amount_in > 0) {
+                    refPrice = stripFeeExclusive(refPrice, isBuy, match.tier.fee / match.tier.amount_in);
+                }
                 tierInfo = {
                     matched_pct: parseFloat(match.tier.pct.toFixed(4)),
                     mode: match.mode,
@@ -119,6 +127,9 @@ class QuotePriceVerify {
             }
             else {
                 refPrice = isBuy ? cached.askPrice : cached.bidPrice;
+                if (params.feeExclusiveExec && params.feeRateBps && params.feeRateBps > 0) {
+                    refPrice = stripFeeExclusive(refPrice, isBuy, params.feeRateBps / 10000);
+                }
             }
             if (refPrice <= 0)
                 continue;

package/dist/types/index.d.ts

@@ -19,6 +19,21 @@ export interface SolanaAccountUpdateEvent {
     accountType: SolanaPoolAccountType;
     accountData?: Buffer | string;
 }
+export interface SolanaSwapVerifyEventData {
+    kind: 'swap_verify';
+    provider_id: string;
+    event_time: number;
+    dex_id: string;
+    pool_address: string;
+    pool_name: string;
+    slot: number;
+    tx_index: number;
+    tx_hash: string;
+    block_time: number;
+    amount0: string;
+    amount1: string;
+}
+export declare const EVENT_POOL_SWAP_VERIFY = "EVENT_POOL_SWAP_VERIFY";
 export interface SolanaBlockMetaUpdateEvent {
     slot: number;
     blockHash: string;

package/dist/types/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaPoolAccountType = void 0;
+exports.EVENT_POOL_SWAP_VERIFY = exports.SolanaPoolAccountType = void 0;
 var SolanaPoolAccountType;
 (function (SolanaPoolAccountType) {
     SolanaPoolAccountType["POOL"] = "pool";
@@ -9,3 +9,4 @@ var SolanaPoolAccountType;
     SolanaPoolAccountType["TICK_ARRAY"] = "tickArray";
     SolanaPoolAccountType["BIN_ARRAY"] = "binArray";
 })(SolanaPoolAccountType || (exports.SolanaPoolAccountType = SolanaPoolAccountType = {}));
+exports.EVENT_POOL_SWAP_VERIFY = 'EVENT_POOL_SWAP_VERIFY';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-sol-common",
-  "version": "2.0.75",
+  "version": "2.0.76",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,7 +13,7 @@
     "push": "npm run build && npm publish"
   },
   "dependencies": {
-    "@clonegod/ttd-core": "3.1.88",
+    "@clonegod/ttd-core": "3.1.89",
     "@solana/web3.js": "1.91.6",
     "rpc-websockets": "7.10.0",
     "axios": "1.17.0",

package/src/common/subscribe_account_update.ts

@@ -1,13 +1,22 @@
 import { StandardPoolInfoType } from "@clonegod/ttd-core";
 import { DEX_ID, log_info, log_warn, SERVICE_PORT, WebSocketClient } from "@clonegod/ttd-core/dist";
-import { SolanaPoolAccountUpdateEventData } from "../types";
+import { SolanaPoolAccountUpdateEventData, SolanaSwapVerifyEventData } from "../types";
 
 /**
- * 集中订阅方式，丛 solana-stream 获取池子变化事件，获得poolRawData 
+ * 集中订阅方式，丛 solana-stream 获取池子变化事件，获得poolRawData
  * - 询价：基于池子数据计算价格
  * - 交易使用：交易中需要池子的最新状态
+ *
+ * 同一条 WS 上承载两类消息（按 `kind` 判别）：
+ *   - 账户快照（无 kind）→ callback（刷新本地状态算价）
+ *   - swap-verify（kind:'swap_verify'）→ onSwapVerify（对账报价偏差）
  */
-export function subscribe_pool_account_update(dex_id: DEX_ID, pool_list: StandardPoolInfoType[], callback: (eventData: SolanaPoolAccountUpdateEventData) => void) {
+export function subscribe_pool_account_update(
+    dex_id: DEX_ID,
+    pool_list: StandardPoolInfoType[],
+    callback: (eventData: SolanaPoolAccountUpdateEventData) => void,
+    onSwapVerify?: (eventData: SolanaSwapVerifyEventData) => void,
+) {
     const port = SERVICE_PORT.STREAM_QUOTE_WS;
     const ws_url = `ws://127.0.0.1:${port}`;
     const ws_client = new WebSocketClient(ws_url)
@@ -16,17 +25,23 @@ export function subscribe_pool_account_update(dex_id: DEX_ID, pool_list: Standar
             ws_client.send(JSON.stringify({ dex_id, pool_name, pool_address }))
         })
     })
-    ws_client.onMessage(((eventData: SolanaPoolAccountUpdateEventData): void => {
+    ws_client.onMessage(((eventData: SolanaPoolAccountUpdateEventData | SolanaSwapVerifyEventData): void => {
         // 订阅 ACK（stream-quote 确认订阅成功，无 data 字段）→ 打 info 确认链路通，不当异常告警
         if ((eventData as any).type === 'subscribed') {
             log_info(`subscribe_pool_account_update: ACK ${(eventData as any).ws_id || (eventData as any).pool_address || ''}`);
             return;
         }
-        if (!eventData.data) {
+        // swap-verify 消息：pool-side vault Δ，交给 onSwapVerify 对账（必须早于 !data 判定，本消息无 data 字段）
+        if ((eventData as any).kind === 'swap_verify') {
+            onSwapVerify?.(eventData as SolanaSwapVerifyEventData);
+            return;
+        }
+        const accountData = eventData as SolanaPoolAccountUpdateEventData;
+        if (!accountData.data) {
             log_warn(`subscribe_pool_account_update: no data`, eventData);
             return;
         }
-        callback(eventData);
+        callback(accountData);
     }));
     ws_client.connect();
 }

package/src/quote/abstract_dex_quote.ts

@@ -2,7 +2,7 @@ import {
     AppConfig, QuoteDepthOutput, QuoteResultType, StandardPoolInfoType,
     log_info, log_warn, on_quote_response, report_quote_candidate,
 } from '@clonegod/ttd-core/dist'
-import { SolanaBlockMetaUpdateEvent } from '../types'
+import { SolanaBlockMetaUpdateEvent, SolanaSwapVerifyEventData } from '../types'
 import { SolanaChainOps } from './chain_ops'
 import { SolPoolEvent } from './pool_event'
 import { QuotePriceVerify, CheckSwapParams } from './verify/quote_price_verify'
@@ -15,7 +15,9 @@ import { QuoteTrace } from './quote_trace'
 //       因此去掉 SUI 的 swap/add/remove 事件分类（debouncedEventTypes）。
 //     · 单调水位线用 Solana 账户 writeVersion（= txIndex 对等物）；wire 暂未带 → 缺省按"无序号"处理。
 //     · 无 v3 PriceFeed（同 SUI，省 do_quote_v3）。
-//     · verify swap-amount 对账暂缓（账户快照不含 amount）→ buildSwapVerify 默认 null；cacheQuote 跨源仍生效。
+//     · verify（报价偏差）走**独立的 swap-verify 通道**（非账户快照）：stream-quote 从真实交易的
+//       pre/postTokenBalances 解码订阅池子 vault Δ（DEX 无关）→ WS push → handleSwapVerify → checkSwap。
+//       exec_price = |Δquote/Δbase|（pool-side vault Δ），fee-exclusive 对账（费路由出池的 DEX 由 feeInVault=false 触发剥费）。
 
 /**
  * 流动性一致性策略（设计文档 §2.2 定稿：3 订阅原型）。各 DEX 子类按协议特性声明：
@@ -111,8 +113,13 @@ export abstract class AbstractDexQuote<C extends SolanaChainOps = SolanaChainOps
     protected async refreshStateFromEvent(_poolInfo: StandardPoolInfoType, _evt: SolPoolEvent): Promise<void> {}
     /** 深度（tier 化）；fee 来自链上 load。priceMap 由基类预取。默认 undefined（step 3 各 DEX 逐档实现）。 */
     protected async calculateDepth(_poolInfo: StandardPoolInfoType, _poolAddress: string, _priceMap: Map<string, { price: string } | undefined>): Promise<QuoteDepthOutput | undefined> { return undefined }
-    /** swap → verify 入参；Solana 账户快照暂不含 swap amount，默认 null（待 stream-quote 解码后接）。 */
-    protected buildSwapVerify(_poolInfo: StandardPoolInfoType, _evt: SolPoolEvent): CheckSwapParams | null { return null }
+    /**
+     * verify 口径：池子手续费是否留在 vault 内。
+     *   - true（默认；Raydium/Orca/Meteora 等）：fee 累进储备 → vault Δ 含费 → 与含费报价同口径，不剥费。
+     *   - false（pumpswap：protocol/creator fee 路由出池到独立账户）：vault Δ 不含费 → checkSwap 把参考价剥成 fee-exclusive。
+     * 详见 quote_price_verify CheckSwapParams.feeExclusiveExec。
+     */
+    protected readonly feeInVault: boolean = true
 
     /**
      * slot 门控钩子（仅 consistencyPolicy='slot-gate' 生效）：判断本池"走单触碰的多账户"状态是否 slot 一致。
@@ -160,12 +167,43 @@ export abstract class AbstractDexQuote<C extends SolanaChainOps = SolanaChainOps
         // v1 兜底：new_block 通道（stream-block）
         this.chain.subscribeNewBlock((raw) => this.handleBlockUpdateEvent(raw))
         // v2 事件：pool 账户更新（stream-quote WS）—— 直连 refresh → compute → publish，(block,writeVersion) 水位线兜底
-        this.chain.subscribePoolEvents(this.dexId, Array.from(this.poolInfoMap.values()), async (evt: SolPoolEvent) => {
-            const { bundle, verifyLog } = await this.calculateQuote(evt)
-            if (bundle) this.publishQuote(bundle)
-            // [Verify] 在 [QUOTE OK] 之后打 —— 先报价后验证
-            if (verifyLog) log_info(verifyLog)
-        })
+        this.chain.subscribePoolEvents(
+            this.dexId,
+            Array.from(this.poolInfoMap.values()),
+            async (evt: SolPoolEvent) => {
+                const bundle = await this.calculateQuote(evt)
+                if (bundle) this.publishQuote(bundle)
+            },
+            // swap-verify 通道（链上真实成交 vault Δ）：独立于账户快照，对账缓存报价 → [Verify]
+            (sv: SolanaSwapVerifyEventData) => this.handleSwapVerify(sv),
+        )
+    }
+
+    /**
+     * 消费 stream-quote 推来的 swap-verify（pool-side vault Δ）→ checkSwap 对账缓存报价 → 打 [Verify]。
+     * exec_price 由 |Δquote/Δbase| 算；fee-exclusive 口径由 feeInVault 决定（详见 CheckSwapParams.feeExclusiveExec）。
+     */
+    private handleSwapVerify(sv: SolanaSwapVerifyEventData): void {
+        const poolInfo = this.poolInfoMap.get(sv.pool_address)
+        if (!poolInfo) return
+        const params: CheckSwapParams = {
+            poolAddress: poolInfo.pool_address,
+            poolName: poolInfo.pool_name,
+            blockNumber: Number(sv.slot),
+            txHash: sv.tx_hash || 'swap',
+            amount0: sv.amount0,
+            amount1: sv.amount1,
+            token0Address: poolInfo.tokenA?.address,
+            token1Address: poolInfo.tokenB?.address,
+            token0Decimals: Number(poolInfo.tokenA?.decimals ?? 0),
+            token1Decimals: Number(poolInfo.tokenB?.decimals ?? 0),
+            poolInfo: { tokenA: poolInfo.tokenA, tokenB: poolInfo.tokenB, quote_token: poolInfo.quote_token },
+            swapperDeltaConvention: false,            // amount0/1 是 pool-side vault Δ
+            feeExclusiveExec: !this.feeInVault,        // 费路由出池（pumpswap）→ 剥参考价的费
+            feeRateBps: poolInfo.fee_rate,             // market-data 强制整数 bps
+        }
+        const verifyLog = this.quotePriceVerify.checkSwap(params)
+        if (verifyLog) log_info(verifyLog)
     }
 
     // ════════════ 事件处理（基类）════════════
@@ -192,9 +230,11 @@ export abstract class AbstractDexQuote<C extends SolanaChainOps = SolanaChainOps
 
     private async handleBlockUpdateEvent(eventData: string): Promise<void> {
         const parsed = JSON.parse(eventData) as SolanaBlockMetaUpdateEvent
-        // slot/blockTime 可能是 protobuf u64 字符串 → 在"blockNumber"归一化边界统一转 number
+        // slot 可能是 protobuf u64 字符串 → 在"blockNumber"归一化边界统一转 number
         const slot = Number(parsed.slot)
-        const blockTime = Number(parsed.blockTime)
+        // streamTimestamp 用本地接收 ms（recvBlockTime），与 v2 的 event_time(ms) 同单位；
+        // 链上 blockTime 是秒，直接当时间戳会让 analyze 延迟列混入绝对秒值（与 ms 相减失真）
+        const streamRecvMs = Number(parsed.recvBlockTime) || Date.now()
         this.assertValidBlockNumber(slot, `${this.dexId} block-event`)
         this.latestBlockSlot = slot   // v1 兜底询价取当前 slot 用（动态费 currentPoint）
         for (const poolInfo of this.poolInfoMap.values()) {
@@ -203,21 +243,18 @@ export abstract class AbstractDexQuote<C extends SolanaChainOps = SolanaChainOps
             const last = this.poolLastQuoteTimeMap.get(poolAddress) || 0
             if (now - last >= this.MIN_QUOTE_INTERVAL_MS) {
                 this.poolLastQuoteTimeMap.set(poolAddress, now)   // await 前占位，防节流被打穿
-                const result = await this.calculateQuoteForPool(poolInfo, blockTime, slot)
+                const result = await this.calculateQuoteForPool(poolInfo, streamRecvMs, slot)
                 if (result) this.publishQuote(result)
             }
         }
     }
 
-    private async calculateQuote(evt: SolPoolEvent): Promise<{ bundle: QuoteBundle | null, verifyLog?: string }> {
+    private async calculateQuote(evt: SolPoolEvent): Promise<QuoteBundle | null> {
         const poolInfo = this.poolInfoMap.get(evt.pool_address)
-        if (!poolInfo) return { bundle: null }
+        if (!poolInfo) return null
         this.assertValidBlockNumber(evt.blockNumber, `${this.dexId} ${poolInfo.pool_name} account-update`)
 
-        // swap verify（唯一入口）。SOL 账户快照默认无 swap amount → buildSwapVerify 返回 null 即跳过。
-        let verifyLog: string | undefined
-        const v = this.buildSwapVerify(poolInfo, evt)
-        if (v) verifyLog = this.quotePriceVerify.checkSwap(v) || undefined
+        // 注：报价偏差 verify 不在此（账户快照不含 swap amount），走独立 swap-verify 通道（handleSwapVerify）。
 
         // 状态更新：每个账户快照都做（不受报价 staleness 短路影响）。
         // 例外：乱序晚到的旧 writeVersion 跳过，防状态回拉（writeVersion 缺省时无条件应用）。
@@ -226,15 +263,14 @@ export abstract class AbstractDexQuote<C extends SolanaChainOps = SolanaChainOps
         if (!skipApply) await this.refreshStateFromEvent(poolInfo, evt)
 
         // compute 前短路：已陈旧 → 跳过重算+推送（状态已更新）
-        if (hasWv && this.isStaleUpdate(evt.pool_address, evt.blockNumber, evt.writeVersion as number)) return { bundle: null, verifyLog }
+        if (hasWv && this.isStaleUpdate(evt.pool_address, evt.blockNumber, evt.writeVersion as number)) return null
 
         // slot 门控（slot-gate 协议）：走单触碰的多账户 slot 不一致 → 本拍不报价，等落后账户的下一条更新重触发
         if (this.consistencyPolicy === 'slot-gate' && !this.isStateConsistentForQuote(poolInfo)) {
-            return { bundle: null, verifyLog }
+            return null
         }
 
-        const bundle = await this.calculateQuoteForPool(poolInfo, evt.blockTime, evt.blockNumber, evt)
-        return { bundle, verifyLog }
+        return this.calculateQuoteForPool(poolInfo, evt.blockTime, evt.blockNumber, evt)
     }
 
     private async calculateQuoteForPool(poolInfo: StandardPoolInfoType, streamTimestamp: number, blockNumber: number, evt?: SolPoolEvent): Promise<QuoteBundle | null> {

package/src/quote/chain_ops.ts

@@ -1,6 +1,7 @@
 import { AppConfig, CHAIN_ID, DEX_ID, log_warn, StandardPoolInfoType } from '@clonegod/ttd-core/dist'
 import { Connection, PublicKey } from '@solana/web3.js'
 import { subscribe_pool_account_update } from '../common/subscribe_account_update'
+import { SolanaSwapVerifyEventData } from '../types'
 import { SolPoolEvent, toSolPoolEvent } from './pool_event'
 import { TokenPriceCache } from './pricing/token_price_cache'
 
@@ -75,17 +76,38 @@ export class SolanaChainOps {
      * 订阅池子账户更新（v2 触发）—— 消费 stream-quote 的 WS 通道。
      * subscribe_pool_account_update 内部 onOpen 时只 send 注册池，stream-quote 据此扇出；
      * 这里把原始 wire 归一化为 SolPoolEvent 再回调。
+     *
+     * onSwapVerify（可选）：同一 WS 上的 swap-verify 消息（链上真实成交 vault Δ），用于报价偏差对账。
      */
-    subscribePoolEvents(dexId: string, pools: StandardPoolInfoType[], handler: (evt: SolPoolEvent) => void): void {
+    subscribePoolEvents(
+        dexId: string,
+        pools: StandardPoolInfoType[],
+        handler: (evt: SolPoolEvent) => void,
+        onSwapVerify?: (evt: SolanaSwapVerifyEventData) => void,
+    ): void {
         const dex = dexId.toUpperCase() as DEX_ID
         const poolSet = new Set(pools.map(p => p.pool_address))
-        subscribe_pool_account_update(dex, pools, (data) => {
-            try {
-                if (!poolSet.has(data.pool_address)) return
-                handler(toSolPoolEvent(data))
-            } catch (e) {
-                log_warn(`[SolanaChainOps] bad pool account update`, data)
-            }
-        })
+        subscribe_pool_account_update(
+            dex,
+            pools,
+            (data) => {
+                try {
+                    if (!poolSet.has(data.pool_address)) return
+                    handler(toSolPoolEvent(data))
+                } catch (e) {
+                    log_warn(`[SolanaChainOps] bad pool account update`, data)
+                }
+            },
+            onSwapVerify
+                ? (sv) => {
+                    try {
+                        if (!poolSet.has(sv.pool_address)) return
+                        onSwapVerify(sv)
+                    } catch (e) {
+                        log_warn(`[SolanaChainOps] bad swap-verify event`, sv)
+                    }
+                }
+                : undefined,
+        )
     }
 }

package/src/quote/pool_event.ts

@@ -18,8 +18,9 @@ import { SolanaPoolAccountUpdateEventData } from '../types'
  *     AMM 聚合快照取 pool+vaultA+vaultB 三账户的 max writeVersion。
  *     （writeVersion 缺省时基类回退"无序号无条件推"，对齐 SUI 缺 txIndex 行为，防御性兜底。）
  *
- * verify（swap amount 对账）暂缓：SOL 账户快照不含 swap amount，buildSwapVerify 默认返回 null，
- *   待 stream-quote 解码 swap amount 后再接（设计文档 §2.4 / verify 跨源 cacheQuote 仍生效）。
+ * verify（swap amount 对账）走**独立的 swap-verify 通道**（不在账户快照里）：stream-quote 从真实交易
+ *   pre/postTokenBalances 解码订阅池子 vault Δ → WS push（SolanaSwapVerifyEventData）→ 询价进程 checkSwap。
+ *   故 SolPoolEvent 仍只承载状态快照，不带 swap amount（详见 abstract_dex_quote.handleSwapVerify）。
  */
 export interface SolPoolEvent {
     pool_address: string

package/src/quote/pool_subscription_registry.ts

@@ -62,10 +62,16 @@ export async function unregisterPoolSubscriptions(appConfig: AppConfig, quote_ap
 
 /**
  * 询价进程启动后调用一次：确保 helius provider + 注册全部池子 + 装退出时自动 unregister。
- * quote_app_id 取 env_args.app_name（每个 DEX 询价进程唯一）。
+ * quote_app_id **必须 = PM2 进程名**（pm2 注入 process.env.name），与 trade-mgt register/reconcile 用的 app_id 一致。
+ * 否则 trade-mgt 的 60s reconcile 按 PM2 进程名核对，会把本进程自注册的订阅当"孤儿"注销 → 订阅消失、收不到事件。
+ * **取不到则 fail-loud（绝不兜底）**：塌成 'sol-quote' 这类 PM2 里不存在的名字 = 必被 reconcile 清掉，等于没注册还掩盖问题。
  */
 export async function attachPoolSubscriptionLifecycle(appConfig: AppConfig, pools: StandardPoolInfoType[]): Promise<void> {
-    const quote_app_id = String(appConfig.env_args.app_name || '').toLowerCase() || 'sol-quote'
+    const quote_app_id = process.env.name || String(appConfig.env_args.app_name || '')
+    if (!quote_app_id) {
+        throw new Error('[pool/subscriptions] 无法确定 quote_app_id：process.env.name(PM2 进程名) 与 APP_NAME 均为空。'
+            + '询价进程必须由 PM2/trade-mgt 以确定进程名启动，否则订阅会被 reconcile 当孤儿清除。')
+    }
     await registerPoolSubscriptions(appConfig, pools, quote_app_id)
 
     let cleaned = false

package/src/quote/verify/quote_price_verify.ts

@@ -119,6 +119,20 @@ function pickMatchingTier(tiers: QuoteTier[], actualAmountIn: number): TierMatch
     return { tier: top, mode: 'extrapolated_high', lo_pct: top.pct, hi_pct: null };
 }
 
+/**
+ * 把含费报价价剥成 fee-exclusive（曲线价），与"费路由出池"DEX（pumpswap）的 vault Δ exec 同口径。
+ *
+ * 关键：费总是把 ask/bid **向两侧各撑开** r（曲线价 M 在中间），方向**不对称**：
+ *   - ask(买基础币) = M / (1 − r)   → ask_excl = ask × (1 − r)
+ *   - bid(卖基础币) = M × (1 − r)   → bid_excl = bid / (1 − r)   ← 是除，不是乘！
+ * 不论费记输入侧还是输出侧（pumpswap 实测两种都有），上式都成立（逐项核对见 session memory）。
+ * ask/bid 同为 quote/base 口径（calculateStandardPrice），仅方向决定撑开符号。
+ */
+function stripFeeExclusive(refPrice: number, isBuy: boolean, r: number): number {
+    if (!(r > 0) || r >= 1) return refPrice;
+    return isBuy ? refPrice * (1 - r) : refPrice / (1 - r);
+}
+
 export interface CheckSwapParams {
     poolAddress: string;
     poolName: string;
@@ -142,6 +156,19 @@ export interface CheckSwapParams {
      * V4 caller 必须传 true，否则 side 会被算反（参见 tx 0xea45784b... / 0xdae0faa7... 验证）。
      */
     swapperDeltaConvention?: boolean;
+    /**
+     * fee-exclusive 对账口径（Solana pool-side vault Δ 用）。
+     *
+     * 背景：exec_price 由 **pool vault Δ** 算（Δquote/Δbase）。vault Δ 是否含费**因 DEX 而异**：
+     *   - 费留池内（Raydium/Orca/Meteora 等）：vault Δ 含费 → 与"含费 tier 价"同口径 → 不剥（false，默认）。
+     *   - 费路由出池（pumpswap protocol/creator fee 进独立账户）：vault Δ 不含费 → 须把参考价剥成 fee-exclusive
+     *     才与 vault Δ 同口径（否则系统性偏差≈费率）。
+     * 为 true 时：refPrice ×= (amount_in − fee)/amount_in（tier 模式，用该档自身的含费/费额）；
+     *   scalar 兜底用 (1 − feeRateBps/1e4) 一阶近似。
+     */
+    feeExclusiveExec?: boolean;
+    /** 池子费率（bps）；feeExclusiveExec 且 scalar 兜底（无 tier）时用作一阶剥费因子。 */
+    feeRateBps?: number;
 }
 
 // ========== 主类 ==========
@@ -276,6 +303,11 @@ export class QuotePriceVerify {
                 const match = pickMatchingTier(tiers, swapData.inputAmountUi);
                 if (!match) continue;
                 refPrice = match.tier.price;
+                // fee-exclusive 对账：把含费 tier 价剥成 fee-exclusive，与 fee-out-of-vault DEX（pumpswap）的 vault Δ 同口径。
+                // r = 该档费率（fee/amount_in，amount_in 含费）。
+                if (params.feeExclusiveExec && match.tier.amount_in > 0) {
+                    refPrice = stripFeeExclusive(refPrice, isBuy, match.tier.fee / match.tier.amount_in);
+                }
                 tierInfo = {
                     matched_pct: parseFloat(match.tier.pct.toFixed(4)),
                     mode: match.mode,
@@ -286,6 +318,10 @@ export class QuotePriceVerify {
             } else {
                 // scalar fallback：旧 DEX 包未传 tiers 时使用
                 refPrice = isBuy ? cached.askPrice : cached.bidPrice;
+                // scalar 无 tier 费额 → 用池子费率一阶剥费（feeExclusiveExec 时）
+                if (params.feeExclusiveExec && params.feeRateBps && params.feeRateBps > 0) {
+                    refPrice = stripFeeExclusive(refPrice, isBuy, params.feeRateBps / 10000);
+                }
             }
 
             if (refPrice <= 0) continue;

package/src/types/index.ts

@@ -34,6 +34,38 @@ export interface SolanaAccountUpdateEvent {
     accountData?: Buffer | string; // 账户原始数据
 }
 
+/**
+ * 链上 swap 的 **pool-side vault Δ** 事件（verify 报价偏差用）。
+ *
+ * 由 stream-quote 从真实交易的 pre/postTokenBalances 解码订阅池子 vaultA/vaultB 的余额差，
+ * 经 WS push（与账户快照同通道，按 dex_id_pool_name_pool_address 路由）推给询价进程，
+ * 询价进程用它对账缓存报价（exec_price = |Δquote/Δbase|，fee-exclusive 口径，见 quote_price_verify）。
+ *
+ * 与 SolanaPoolAccountUpdateEventData 的区别：
+ *   - 后者是**账户最新快照**（base64，用于刷新本地状态算价）；
+ *   - 本结构是**一笔 swap 的成交量**（vault Δ，用于验证报价准不准）。
+ *   - 用 `kind:'swap_verify'` 判别（账户快照消息无 kind 字段）。
+ */
+export interface SolanaSwapVerifyEventData {
+    kind: 'swap_verify'
+    provider_id: string
+    event_time: number           // stream 本地收到 tx 的 ms（新鲜度/延迟用）
+    dex_id: string
+    pool_address: string
+    pool_name: string
+    slot: number                 // swap 所在 slot（= verify 的 swap_block）
+    tx_index: number             // 块内交易序号
+    tx_hash: string
+    block_time: number           // 链上出块时间 ms；0=未知，由消费端处理
+    /** vaultA(base/token0) 余额 Δ；pool-side signed（>0=流入池子）；raw（含 decimals） */
+    amount0: string
+    /** vaultB(quote/token1) 余额 Δ；pool-side signed */
+    amount1: string
+}
+
+/** swap-verify 事件总线名（stream-quote 内 appConfig.emit → ws_push_server 路由）。 */
+export const EVENT_POOL_SWAP_VERIFY = 'EVENT_POOL_SWAP_VERIFY'
+
 /**
  * Solana 区块元数据更新事件
  */