@clonegod/ttd-sol-common 2.0.67 → 2.0.68

package/dist/quote/pool_event.d.ts

@@ -0,0 +1,20 @@
+import { SolanaPoolAccountUpdateEventData } from '../types';
+export interface SolPoolEvent {
+    pool_address: string;
+    dex_id: string;
+    pool_name: string;
+    blockNumber: number;
+    writeVersion?: number;
+    txHash: string;
+    blockTime: number;
+    poolAccountData: string;
+    vaultAAccountData?: string;
+    vaultBAccountData?: string;
+    subAccount?: {
+        role: string;
+        address: string;
+        data: string;
+    };
+    raw: SolanaPoolAccountUpdateEventData;
+}
+export declare function toSolPoolEvent(data: SolanaPoolAccountUpdateEventData): SolPoolEvent;

package/dist/quote/pool_event.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSolPoolEvent = toSolPoolEvent;
+function toSolPoolEvent(data) {
+    const d = data.data;
+    return {
+        pool_address: data.pool_address,
+        dex_id: data.dex_id,
+        pool_name: data.pool_name,
+        blockNumber: d.slot,
+        writeVersion: d.write_version,
+        txHash: d.tx_hash || 'account',
+        blockTime: data.event_time || 0,
+        poolAccountData: d.pool_account_data,
+        vaultAAccountData: d.vaultA_account_data,
+        vaultBAccountData: d.vaultB_account_data,
+        subAccount: d.sub_account
+            ? { role: d.sub_account.role, address: d.sub_account.account, data: d.sub_account.account_data }
+            : undefined,
+        raw: data,
+    };
+}

package/dist/quote/pool_subscription_registry.d.ts

@@ -0,0 +1,4 @@
+import { AppConfig, StandardPoolInfoType } from '@clonegod/ttd-core/dist';
+export declare function registerPoolSubscriptions(appConfig: AppConfig, pools: StandardPoolInfoType[], quote_app_id: string): Promise<void>;
+export declare function unregisterPoolSubscriptions(appConfig: AppConfig, quote_app_id: string): Promise<void>;
+export declare function attachPoolSubscriptionLifecycle(appConfig: AppConfig, pools: StandardPoolInfoType[]): Promise<void>;

package/dist/quote/pool_subscription_registry.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPoolSubscriptions = registerPoolSubscriptions;
+exports.unregisterPoolSubscriptions = unregisterPoolSubscriptions;
+exports.attachPoolSubscriptionLifecycle = attachPoolSubscriptionLifecycle;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const grpc_provider_registry_1 = require("../grpc/grpc_provider_registry");
+function configCenterBase(appConfig) {
+    const chain = appConfig.env_args.chain_id;
+    let host = String(appConfig.env_args.config_center_host || '127.0.0.1').trim();
+    if (!host.includes(':'))
+        host = `${host}:${dist_1.SERVICE_PORT.CONFIG_CENTER_HTTP}`;
+    return `http://${host}/${chain}/config`;
+}
+async function registerPoolSubscriptions(appConfig, pools, quote_app_id) {
+    const provider = await (0, grpc_provider_registry_1.resolveGrpcProvider)(appConfig.arb_cache.redis_cmd, appConfig.env_args.chain_id);
+    const provider_ids = [provider.id];
+    const base = configCenterBase(appConfig);
+    let ok = 0;
+    for (const p of pools) {
+        try {
+            await dist_1.HttpUtil.post(`${base}/quote/register`, {
+                pool_address: p.pool_address,
+                provider_ids,
+                quote_app_id,
+                pair: p.pair,
+                dex_id: p.dex_id,
+                pool_name: p.pool_name,
+                fee_rate: p.fee_rate,
+            });
+            ok++;
+        }
+        catch (e) {
+            (0, dist_1.log_warn)(`[pool/subscriptions] register ${p.pool_address} failed: ${e.message}`);
+        }
+    }
+    (0, dist_1.log_info)(`[pool/subscriptions] registered ${ok}/${pools.length} pools by ${quote_app_id} → provider=${provider.id}`);
+}
+async function unregisterPoolSubscriptions(appConfig, quote_app_id) {
+    try {
+        await dist_1.HttpUtil.post(`${configCenterBase(appConfig)}/quote/unregister`, { quote_app_id });
+        (0, dist_1.log_info)(`[pool/subscriptions] unregistered all pools by ${quote_app_id}`);
+    }
+    catch (e) {
+        (0, dist_1.log_warn)(`[pool/subscriptions] unregister failed: ${e.message}`);
+    }
+}
+async function attachPoolSubscriptionLifecycle(appConfig, pools) {
+    const quote_app_id = String(appConfig.env_args.app_name || '').toLowerCase() || 'sol-quote';
+    await registerPoolSubscriptions(appConfig, pools, quote_app_id);
+    let cleaned = false;
+    const cleanup = async (sig) => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        (0, dist_1.log_info)(`[pool/subscriptions] ${sig} → unregister ${quote_app_id}`);
+        await unregisterPoolSubscriptions(appConfig, quote_app_id);
+        process.exit(0);
+    };
+    process.on('SIGINT', () => void cleanup('SIGINT'));
+    process.on('SIGTERM', () => void cleanup('SIGTERM'));
+}

package/dist/quote/quote_amount.d.ts

@@ -0,0 +1,4 @@
+import { StandardPoolInfoType } from '@clonegod/ttd-core';
+import Decimal from 'decimal.js';
+export declare function getQuoteAmountUsd(poolInfo: StandardPoolInfoType): number;
+export declare function usdToTokenUiAmount(amountInUsd: number, tokenAddress: string): Promise<Decimal>;

package/dist/quote/quote_amount.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQuoteAmountUsd = getQuoteAmountUsd;
+exports.usdToTokenUiAmount = usdToTokenUiAmount;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+function getQuoteAmountUsd(poolInfo) {
+    const envValue = Number(process.env.QUOTE_AMOUNT_USD);
+    if (envValue > 0) {
+        return envValue;
+    }
+    return poolInfo.quote_amount_usd;
+}
+async function usdToTokenUiAmount(amountInUsd, tokenAddress) {
+    const priceMap = await (0, ttd_core_1.get_solana_token_price_info)([tokenAddress]);
+    const price = priceMap.get(tokenAddress)?.price;
+    if (!price || price === '0') {
+        throw new Error(`price not available for ${tokenAddress}`);
+    }
+    return new decimal_js_1.default(amountInUsd).div(new decimal_js_1.default(price));
+}

package/dist/quote/quote_trace.d.ts

@@ -0,0 +1,16 @@
+export declare class QuoteTrace {
+    readonly poolName: string;
+    readonly poolAddress: string;
+    blockNumber: number;
+    source: string;
+    private startTime;
+    private marks;
+    private data;
+    private error;
+    constructor(poolName: string, poolAddress: string, blockNumber?: number, source?: string);
+    mark(name: string): void;
+    set(key: string, value: any): void;
+    markError(stage: string, message: string): void;
+    private buildTimeline;
+    flush(): void;
+}

package/dist/quote/quote_trace.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuoteTrace = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const logger = (0, ttd_core_1.createLogger)(__filename);
+class QuoteTrace {
+    constructor(poolName, poolAddress, blockNumber = 0, source = '') {
+        this.poolName = poolName;
+        this.poolAddress = poolAddress;
+        this.blockNumber = blockNumber;
+        this.source = source;
+        this.startTime = Date.now();
+        this.marks = [];
+        this.data = {};
+        this.error = null;
+    }
+    mark(name) {
+        this.marks.push({ name, elapsed: Date.now() - this.startTime });
+    }
+    set(key, value) { this.data[key] = value; }
+    markError(stage, message) { this.error = { stage, message }; }
+    buildTimeline() {
+        if (this.marks.length === 0)
+            return '(no marks)';
+        let prev = 0;
+        const parts = this.marks.map(m => { const d = m.elapsed - prev; prev = m.elapsed; return `${m.name}(${d}ms)`; });
+        return `${parts.join(' -> ')} = ${this.marks[this.marks.length - 1].elapsed}ms`;
+    }
+    flush() {
+        const timeline = this.buildTimeline();
+        if (this.error) {
+            logger.error(`[QUOTE FAILED] ${this.poolName} | stage=${this.error.stage} | source=${this.source} | ${this.error.message}`, new Error(this.error.message));
+            logger.info(`[QUOTE FAILED detail] ${this.poolName}`, { timeline, error_stage: this.error.stage, source: this.source, ...this.data });
+        }
+        else {
+            logger.debug(`[QUOTE OK] ${this.poolName} blk=${this.blockNumber} source=${this.source}`, { timeline, ...this.data });
+        }
+    }
+}
+exports.QuoteTrace = QuoteTrace;

package/dist/quote/tick/clmm_tick_math.d.ts

@@ -0,0 +1,5 @@
+export declare const MIN_TICK = -443636;
+export declare const MAX_TICK = 443636;
+export declare const MIN_SQRT_PRICE_X64 = 4295048016n;
+export declare const MAX_SQRT_PRICE_X64 = 79226673521066979257578248091n;
+export declare function getSqrtPriceX64FromTick(tick: number): bigint;

package/dist/quote/tick/clmm_tick_math.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SQRT_PRICE_X64 = exports.MIN_SQRT_PRICE_X64 = exports.MAX_TICK = exports.MIN_TICK = void 0;
+exports.getSqrtPriceX64FromTick = getSqrtPriceX64FromTick;
+exports.MIN_TICK = -443636;
+exports.MAX_TICK = 443636;
+exports.MIN_SQRT_PRICE_X64 = 4295048016n;
+exports.MAX_SQRT_PRICE_X64 = 79226673521066979257578248091n;
+const MaxUint128 = (1n << 128n) - 1n;
+function mulRightShift(val, mulBy) {
+    return (val * mulBy) >> 64n;
+}
+function getSqrtPriceX64FromTick(tick) {
+    if (!Number.isInteger(tick)) {
+        throw new Error('tick must be integer');
+    }
+    if (tick < exports.MIN_TICK || tick > exports.MAX_TICK) {
+        throw new Error('tick must be in MIN_TICK and MAX_TICK');
+    }
+    const tickAbs = tick < 0 ? -tick : tick;
+    let ratio = (tickAbs & 0x1) !== 0 ? 18445821805675395072n : 18446744073709551616n;
+    if ((tickAbs & 0x2) !== 0)
+        ratio = mulRightShift(ratio, 18444899583751176192n);
+    if ((tickAbs & 0x4) !== 0)
+        ratio = mulRightShift(ratio, 18443055278223355904n);
+    if ((tickAbs & 0x8) !== 0)
+        ratio = mulRightShift(ratio, 18439367220385607680n);
+    if ((tickAbs & 0x10) !== 0)
+        ratio = mulRightShift(ratio, 18431993317065453568n);
+    if ((tickAbs & 0x20) !== 0)
+        ratio = mulRightShift(ratio, 18417254355718170624n);
+    if ((tickAbs & 0x40) !== 0)
+        ratio = mulRightShift(ratio, 18387811781193609216n);
+    if ((tickAbs & 0x80) !== 0)
+        ratio = mulRightShift(ratio, 18329067761203558400n);
+    if ((tickAbs & 0x100) !== 0)
+        ratio = mulRightShift(ratio, 18212142134806163456n);
+    if ((tickAbs & 0x200) !== 0)
+        ratio = mulRightShift(ratio, 17980523815641700352n);
+    if ((tickAbs & 0x400) !== 0)
+        ratio = mulRightShift(ratio, 17526086738831433728n);
+    if ((tickAbs & 0x800) !== 0)
+        ratio = mulRightShift(ratio, 16651378430235570176n);
+    if ((tickAbs & 0x1000) !== 0)
+        ratio = mulRightShift(ratio, 15030750278694412288n);
+    if ((tickAbs & 0x2000) !== 0)
+        ratio = mulRightShift(ratio, 12247334978884435968n);
+    if ((tickAbs & 0x4000) !== 0)
+        ratio = mulRightShift(ratio, 8131365268886854656n);
+    if ((tickAbs & 0x8000) !== 0)
+        ratio = mulRightShift(ratio, 3584323654725218816n);
+    if ((tickAbs & 0x10000) !== 0)
+        ratio = mulRightShift(ratio, 696457651848324352n);
+    if ((tickAbs & 0x20000) !== 0)
+        ratio = mulRightShift(ratio, 26294789957507116n);
+    if ((tickAbs & 0x40000) !== 0)
+        ratio = mulRightShift(ratio, 37481735321082n);
+    if (tick > 0)
+        ratio = MaxUint128 / ratio;
+    return ratio;
+}

package/dist/quote/tick/index.d.ts

@@ -0,0 +1 @@
+export * from './clmm_tick_math';

package/dist/{config → quote/tick}/index.js

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./SolanaTradeAppConfig"), exports);
+__exportStar(require("./clmm_tick_math"), exports);

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

@@ -0,0 +1 @@
+export * from './quote_price_verify';

package/dist/quote/verify/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./quote_price_verify"), exports);

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

@@ -0,0 +1,30 @@
+import { QuoteTier } from '@clonegod/ttd-core';
+export interface CheckSwapParams {
+    poolAddress: string;
+    poolName: string;
+    blockNumber: number;
+    txHash: string;
+    amount0: string;
+    amount1: string;
+    token0Address: string;
+    token1Address: string;
+    token0Decimals: number;
+    token1Decimals: number;
+    poolInfo: {
+        tokenA: any;
+        tokenB: any;
+        quote_token: string;
+    };
+    swapperDeltaConvention?: boolean;
+}
+export declare class QuotePriceVerify {
+    private quoteCache;
+    private get enabled();
+    cacheQuote(poolAddress: string, priceId: string, source: string, askPrice: number, bidPrice: number, blockNumber: number, quoteAmountUsd: number, token0PriceUsd?: number, token1PriceUsd?: number, tiers?: {
+        askTiers?: QuoteTier[];
+        bidTiers?: QuoteTier[];
+    }): void;
+    checkSwap(params: CheckSwapParams): string | void;
+    private deriveSwapDirection;
+    private compareAndLog;
+}

package/dist/quote/verify/quote_price_verify.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuotePriceVerify = void 0;
+const trade_direction_1 = require("../../utils/trade_direction");
+const ttd_core_1 = require("@clonegod/ttd-core");
+function pickMatchingTier(tiers, actualAmountIn) {
+    if (!tiers || tiers.length === 0)
+        return null;
+    if (tiers.length === 1)
+        return { tier: tiers[0], mode: 'single_tier', lo_pct: tiers[0].pct, hi_pct: tiers[0].pct };
+    const sorted = [...tiers].sort((a, b) => a.amount_in - b.amount_in);
+    const top = sorted[sorted.length - 1];
+    if (actualAmountIn < sorted[0].amount_in) {
+        return { tier: sorted[0], mode: 'extrapolated_low', lo_pct: null, hi_pct: sorted[0].pct };
+    }
+    if (actualAmountIn > top.amount_in) {
+        return { tier: top, mode: 'extrapolated_high', lo_pct: top.pct, hi_pct: null };
+    }
+    for (let i = 0; i < sorted.length - 1; i++) {
+        const lower = sorted[i];
+        const upper = sorted[i + 1];
+        if (actualAmountIn >= lower.amount_in && actualAmountIn <= upper.amount_in) {
+            if (actualAmountIn === lower.amount_in)
+                return { tier: lower, mode: 'exact', lo_pct: lower.pct, hi_pct: lower.pct };
+            if (actualAmountIn === upper.amount_in)
+                return { tier: upper, mode: 'exact', lo_pct: upper.pct, hi_pct: upper.pct };
+            const span = upper.amount_in - lower.amount_in;
+            if (span <= 0)
+                return { tier: lower, mode: 'exact', lo_pct: lower.pct, hi_pct: lower.pct };
+            const ratio = (actualAmountIn - lower.amount_in) / span;
+            const lerp = (a, b) => a + ratio * (b - a);
+            return {
+                tier: {
+                    pct: lerp(lower.pct, upper.pct),
+                    price: lerp(lower.price, upper.price),
+                    amount: lerp(lower.amount, upper.amount),
+                    amount_in: actualAmountIn,
+                    amount_in_usd: lerp(lower.amount_in_usd, upper.amount_in_usd),
+                    fee: lerp(lower.fee, upper.fee),
+                    fee_usd: lerp(lower.fee_usd, upper.fee_usd),
+                },
+                mode: 'interpolated',
+                lo_pct: lower.pct,
+                hi_pct: upper.pct,
+            };
+        }
+    }
+    return { tier: top, mode: 'extrapolated_high', lo_pct: top.pct, hi_pct: null };
+}
+class QuotePriceVerify {
+    constructor() {
+        this.quoteCache = new Map();
+    }
+    get enabled() {
+        return process.env.VERIFY_QUOTE_PRICE === 'true';
+    }
+    cacheQuote(poolAddress, priceId, source, askPrice, bidPrice, blockNumber, quoteAmountUsd, token0PriceUsd = 0, token1PriceUsd = 0, tiers) {
+        if (!this.enabled)
+            return;
+        if (!source)
+            return;
+        let sourceMap = this.quoteCache.get(poolAddress);
+        if (!sourceMap) {
+            sourceMap = new Map();
+            this.quoteCache.set(poolAddress, sourceMap);
+        }
+        const existing = sourceMap.get(source);
+        const verifiedReferenceBlock = (existing && existing.referenceBlock === blockNumber)
+            ? existing.verifiedReferenceBlock
+            : 0;
+        sourceMap.set(source, {
+            priceId, source, askPrice, bidPrice,
+            askTiers: tiers?.askTiers,
+            bidTiers: tiers?.bidTiers,
+            referenceBlock: blockNumber,
+            verifiedReferenceBlock,
+            quoteAmountUsd,
+            token0PriceUsd, token1PriceUsd,
+        });
+    }
+    checkSwap(params) {
+        if (!this.enabled)
+            return;
+        const { poolAddress, blockNumber, txHash, poolInfo, token0Address } = params;
+        const sourceMap = this.quoteCache.get(poolAddress);
+        if (!sourceMap || sourceMap.size === 0)
+            return;
+        const swapData = this.deriveSwapDirection(params);
+        if (!swapData)
+            return;
+        const direction = (0, trade_direction_1.resolveTradeDirection)(poolInfo, true);
+        const inputIsQuoteToken = swapData.inputTokenAddress.toLowerCase() === direction.quoteToken.address.toLowerCase();
+        const isBuy = inputIsQuoteToken;
+        const execPriceStr = (0, trade_direction_1.calculateStandardPrice)(swapData.inputAmountUi, swapData.outputAmountUi, isBuy);
+        const execPrice = Number(execPriceStr);
+        if (execPrice <= 0)
+            return;
+        const verifiable = [];
+        for (const [source, cached] of sourceMap) {
+            if (blockNumber <= cached.referenceBlock)
+                continue;
+            if (cached.verifiedReferenceBlock === cached.referenceBlock)
+                continue;
+            const tiers = isBuy ? cached.askTiers : cached.bidTiers;
+            let refPrice;
+            let tierInfo;
+            if (tiers && tiers.length > 0) {
+                const match = pickMatchingTier(tiers, swapData.inputAmountUi);
+                if (!match)
+                    continue;
+                refPrice = match.tier.price;
+                tierInfo = {
+                    matched_pct: parseFloat(match.tier.pct.toFixed(4)),
+                    mode: match.mode,
+                    tier_amount_in: match.tier.amount_in,
+                    lo_pct: match.lo_pct,
+                    hi_pct: match.hi_pct,
+                };
+            }
+            else {
+                refPrice = isBuy ? cached.askPrice : cached.bidPrice;
+            }
+            if (refPrice <= 0)
+                continue;
+            cached.verifiedReferenceBlock = cached.referenceBlock;
+            const diff_bps = (refPrice - execPrice) / refPrice * 10000;
+            verifiable.push({ source, cached, refPrice, diff_bps, tierInfo });
+        }
+        if (verifiable.length === 0)
+            return;
+        verifiable.sort((a, b) => b.cached.referenceBlock - a.cached.referenceBlock);
+        const primary = verifiable[0];
+        const sources = {};
+        for (const r of verifiable) {
+            sources[r.source] = {
+                ask: r.cached.askPrice,
+                bid: r.cached.bidPrice,
+                matched_ref_price: r.refPrice,
+                diff_bps: parseFloat(r.diff_bps.toFixed(1)),
+                quote_block: r.cached.referenceBlock,
+                ...(r.tierInfo && {
+                    matched_pct: r.tierInfo.matched_pct,
+                    tier_mode: r.tierInfo.mode,
+                    tier_amount_in: r.tierInfo.tier_amount_in,
+                }),
+            };
+        }
+        return this.compareAndLog(poolAddress, params.poolName, poolInfo, primary.cached, swapData.inputTokenAddress, swapData.outputTokenAddress, swapData.inputAmountUi, swapData.outputAmountUi, primary.refPrice, execPrice, primary.cached.token0PriceUsd, primary.cached.token1PriceUsd, token0Address, blockNumber, txHash, sources, primary.tierInfo);
+    }
+    deriveSwapDirection(params) {
+        const { amount0, amount1, token0Address, token1Address, token0Decimals, token1Decimals } = params;
+        const sign = params.swapperDeltaConvention ? -1n : 1n;
+        const amt0 = BigInt(amount0) * sign;
+        const amt1 = BigInt(amount1) * sign;
+        if (amt0 === 0n && amt1 === 0n)
+            return null;
+        if (amt0 > 0n && amt1 < 0n) {
+            return {
+                inputTokenAddress: token0Address,
+                outputTokenAddress: token1Address,
+                inputAmountUi: Number(amt0) / Math.pow(10, token0Decimals),
+                outputAmountUi: Number(-amt1) / Math.pow(10, token1Decimals),
+            };
+        }
+        else if (amt0 < 0n && amt1 > 0n) {
+            return {
+                inputTokenAddress: token1Address,
+                outputTokenAddress: token0Address,
+                inputAmountUi: Number(amt1) / Math.pow(10, token1Decimals),
+                outputAmountUi: Number(-amt0) / Math.pow(10, token0Decimals),
+            };
+        }
+        return null;
+    }
+    compareAndLog(poolAddress, poolName, poolInfo, cached, inputTokenAddress, outputTokenAddress, inputAmountUi, outputAmountUi, refPrice, execPriceNum, token0PriceUsd, token1PriceUsd, token0Address, swapBlockNumber, txHash, sources, primaryTierInfo) {
+        if (inputAmountUi <= 0 || outputAmountUi <= 0)
+            return;
+        let swapUsd = 0;
+        if (token0PriceUsd && token1PriceUsd && token0Address) {
+            const inputIsToken0 = inputTokenAddress.toLowerCase() === token0Address.toLowerCase();
+            swapUsd = inputIsToken0
+                ? inputAmountUi * token0PriceUsd
+                : inputAmountUi * token1PriceUsd;
+        }
+        const direction = (0, trade_direction_1.resolveTradeDirection)(poolInfo, true);
+        const baseToken = direction.baseToken;
+        const quoteToken = direction.quoteToken;
+        const inputIsQuoteToken = inputTokenAddress.toLowerCase() === quoteToken.address.toLowerCase();
+        const isBuy = inputIsQuoteToken;
+        const side = isBuy ? 'BUY' : 'SELL';
+        if (refPrice <= 0 || execPriceNum <= 0)
+            return;
+        const diffBps = (refPrice - execPriceNum) / refPrice * 10000;
+        const absDiffBps = Math.abs(diffBps);
+        const status = absDiffBps < 5 ? '✅' : absDiffBps < 10 ? '⚠️' : '❌';
+        const usdStr = swapUsd > 0 ? `$${swapUsd.toFixed(0)}` : '$?';
+        const maxUsd = cached.quoteAmountUsd * 2;
+        const inRange = swapUsd <= 0 || swapUsd <= maxUsd;
+        const rangeTag = inRange ? '' : ' [out]';
+        const tradeFlow = isBuy
+            ? `${inputAmountUi.toFixed(4)} ${quoteToken.symbol} -> ${outputAmountUi.toFixed(4)} ${baseToken.symbol}`
+            : `${inputAmountUi.toFixed(4)} ${baseToken.symbol} -> ${outputAmountUi.toFixed(4)} ${quoteToken.symbol}`;
+        const quoteSrc = cached.source || '?';
+        const quoteTag = `quote[${quoteSrc} blk:${cached.referenceBlock}]`;
+        const swapBlk = swapBlockNumber || '?';
+        const swapTx = txHash ? ` ${txHash.slice(0, 10)}` : '';
+        const swapTag = `swap[blk:${swapBlk}${swapTx}]`;
+        const priceLabel = isBuy ? 'ask' : 'bid';
+        const msg = `  ↳ [Verify] ${side} ${usdStr} (${tradeFlow}) ${quoteTag} ${priceLabel}=${refPrice.toFixed(12)} vs ${swapTag} exec=${execPriceNum.toFixed(12)} diff=${diffBps > 0 ? '+' : ''}${diffBps.toFixed(1)}bps ${status}${rangeTag}`;
+        try {
+            (0, ttd_core_1.report_data_to_analyze)('QuoteVerify', {
+                pool_address: poolAddress,
+                pool_name: poolName,
+                price_id: cached.priceId,
+                source: cached.source,
+                quote_amount_usd: cached.quoteAmountUsd,
+                quote_block: cached.referenceBlock,
+                swap_block: swapBlockNumber,
+                tx_hash: txHash || '',
+                side,
+                ref_price: refPrice,
+                exec_price: execPriceNum,
+                diff_bps: parseFloat(diffBps.toFixed(1)),
+                swap_usd: parseFloat(swapUsd.toFixed(0)),
+                in_range: inRange,
+                input_amount: inputAmountUi,
+                output_amount: outputAmountUi,
+                input_symbol: isBuy ? quoteToken.symbol : baseToken.symbol,
+                output_symbol: isBuy ? baseToken.symbol : quoteToken.symbol,
+                status,
+                time: Date.now(),
+                sources: sources || undefined,
+                ...(primaryTierInfo && {
+                    matched_tier_pct: primaryTierInfo.matched_pct,
+                    matched_tier_mode: primaryTierInfo.mode,
+                    matched_tier_amount_in: primaryTierInfo.tier_amount_in,
+                    matched_tier_lo_pct: primaryTierInfo.lo_pct,
+                    matched_tier_hi_pct: primaryTierInfo.hi_pct,
+                }),
+            });
+        }
+        catch (_) {
+        }
+        return msg;
+    }
+}
+exports.QuotePriceVerify = QuotePriceVerify;

package/dist/trade/index.d.ts

@@ -1,6 +1,5 @@
 export * from './tx_result_check';
 export * from './tx_result_parse';
-export * from '../config/SolanaTradeAppConfig';
 export * from './tx_builder';
 export * from './send';
 export * from './jito_tip_wallets';

package/dist/trade/index.js

@@ -16,7 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./tx_result_check"), exports);
 __exportStar(require("./tx_result_parse"), exports);
-__exportStar(require("../config/SolanaTradeAppConfig"), exports);
 __exportStar(require("./tx_builder"), exports);
 __exportStar(require("./send"), exports);
 __exportStar(require("./jito_tip_wallets"), exports);

package/dist/trade/tx_builder.d.ts

@@ -1,6 +1,6 @@
 import { TradeContext } from "@clonegod/ttd-core/dist";
 import { Connection, Keypair, Transaction, TransactionInstruction } from "@solana/web3.js";
-import { SolanaTradeAppConfig } from "../config/SolanaTradeAppConfig";
+import { SolanaTradeAppConfig } from "../appconfig/SolanaTradeAppConfig";
 import { JitoTipWalletManager } from "./jito_tip_wallets";
 export declare class SolTransactionBuilder {
     appConfig: SolanaTradeAppConfig;

package/dist/trade/tx_result_parse.js

@@ -64,6 +64,7 @@ class TransactionResultParser {
             wallet: owner,
             block_time: blockTime,
             block_number: slot,
+            tx_index: 0,
             txid,
             pool_address,
             tokenA: {

package/dist/types/index.d.ts

@@ -1,7 +1,9 @@
 export declare enum SolanaPoolAccountType {
     POOL = "pool",
     VAULT_A = "vaultA",
-    VAULT_B = "vaultB"
+    VAULT_B = "vaultB",
+    TICK_ARRAY = "tickArray",
+    BIN_ARRAY = "binArray"
 }
 export interface SolanaAccountUpdateEvent {
     recvTimeMs: number;
@@ -35,6 +37,7 @@ export interface SolanaPoolAccountUpdateEventData {
     pool_name: string;
     data: {
         slot: number;
+        write_version?: number;
         tx_hash: string;
         pool_account: string;
         pool_account_data: string;
@@ -42,5 +45,10 @@ export interface SolanaPoolAccountUpdateEventData {
         vaultA_account_data?: string;
         vaultB_account?: string;
         vaultB_account_data?: string;
+        sub_account?: {
+            role: string;
+            account: string;
+            account_data: string;
+        };
     };
 }

package/dist/types/index.js

@@ -6,4 +6,6 @@ var SolanaPoolAccountType;
     SolanaPoolAccountType["POOL"] = "pool";
     SolanaPoolAccountType["VAULT_A"] = "vaultA";
     SolanaPoolAccountType["VAULT_B"] = "vaultB";
+    SolanaPoolAccountType["TICK_ARRAY"] = "tickArray";
+    SolanaPoolAccountType["BIN_ARRAY"] = "binArray";
 })(SolanaPoolAccountType || (exports.SolanaPoolAccountType = SolanaPoolAccountType = {}));

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './trade_direction';