@clonegod/ttd-sol-common 2.0.67 → 2.0.68

package/dist/quote/abstract_dex_quote.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractDexQuote = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const quote_price_verify_1 = require("./verify/quote_price_verify");
+const quote_amount_1 = require("./quote_amount");
+const quote_trace_1 = require("./quote_trace");
+class AbstractDexQuote {
+    constructor(appConfig, chain) {
+        this.poolInfoMap = new Map();
+        this.poolLastQuoteTimeMap = new Map();
+        this.lastPublished = new Map();
+        this.appliedStateWatermark = new Map();
+        this.quotePriceVerify = new quote_price_verify_1.QuotePriceVerify();
+        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.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);
+    }
+    async init(poolList) {
+        (0, dist_1.log_info)(`初始化 ${this.dexId} Quote，共 ${poolList.length} 个池...`);
+        for (const poolInfo of poolList) {
+            if (!this.chain.isValidPoolAddress(poolInfo.pool_address)) {
+                (0, dist_1.log_warn)(`跳过无效的池地址: ${poolInfo.pool_address}`, '');
+                continue;
+            }
+            this.poolInfoMap.set(poolInfo.pool_address, poolInfo);
+        }
+        await this.beforeLoadPools();
+        await Promise.all(Array.from(this.poolInfoMap.values()).map(async (p) => {
+            const summary = await this.loadPool(p);
+            if (summary.verifyProgram)
+                await this.chain.assertProgramDeployed(summary.verifyProgram);
+            (0, dist_1.log_info)(`[QUOTE INIT] ${p.pool_name} (${p.pool_address}) dex=${this.dexId}`, { ...summary });
+        }));
+        this.registerEventHandlers();
+        (0, dist_1.log_info)(`${this.dexId} Quote 初始化完成，${this.poolInfoMap.size} 个有效池`);
+    }
+    async beforeLoadPools() { }
+    getQuoteAmountUsd(poolInfo) { return (0, quote_amount_1.getQuoteAmountUsd)(poolInfo); }
+    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);
+            if (bundle)
+                this.publishQuote(bundle);
+            if (verifyLog)
+                (0, dist_1.log_info)(verifyLog);
+        });
+    }
+    assertValidBlockNumber(blockNumber, ctx) {
+        if (!Number.isInteger(blockNumber) || blockNumber <= 0) {
+            throw new Error(`[block-number] ${ctx}: 非法 blockNumber=${blockNumber}，每条数据源必须携带真实 slot`);
+        }
+    }
+    isStaleUpdate(poolAddr, block, txIndex) {
+        const last = this.lastPublished.get(poolAddr);
+        return !!last && (block < last.block || (block === last.block && txIndex <= last.txIndex));
+    }
+    shouldApplyState(poolAddr, block, txIndex) {
+        const last = this.appliedStateWatermark.get(poolAddr);
+        if (last && (block < last.block || (block === last.block && txIndex <= last.txIndex)))
+            return false;
+        this.appliedStateWatermark.set(poolAddr, { block, txIndex });
+        return true;
+    }
+    async handleBlockUpdateEvent(eventData) {
+        const { slot, blockTime } = JSON.parse(eventData);
+        this.assertValidBlockNumber(slot, `${this.dexId} block-event`);
+        this.latestBlockSlot = slot;
+        for (const poolInfo of this.poolInfoMap.values()) {
+            const poolAddress = poolInfo.pool_address;
+            const now = Date.now();
+            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);
+                if (result)
+                    this.publishQuote(result);
+            }
+        }
+    }
+    async calculateQuote(evt) {
+        const poolInfo = this.poolInfoMap.get(evt.pool_address);
+        if (!poolInfo)
+            return { bundle: 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 };
+        if (this.consistencyPolicy === 'slot-gate' && !this.isStateConsistentForQuote(poolInfo)) {
+            return { bundle: null, verifyLog };
+        }
+        const bundle = await this.calculateQuoteForPool(poolInfo, evt.blockTime, evt.blockNumber, evt);
+        return { bundle, verifyLog };
+    }
+    async calculateQuoteForPool(poolInfo, streamTimestamp, blockNumber, evt) {
+        const { pool_address } = poolInfo;
+        const eventDriven = !!evt;
+        const source = eventDriven ? 'local:v2' : 'rpc:v1';
+        const trace = new quote_trace_1.QuoteTrace(poolInfo.pool_name, pool_address, blockNumber, source);
+        trace.mark('trigger');
+        let stage = 'compute';
+        try {
+            const quote_amount_usd = (0, quote_amount_1.getQuoteAmountUsd)(poolInfo);
+            const quoteStartTime = Date.now();
+            const txid = evt ? (evt.txHash || 'account') : 'block';
+            const txIndex = evt?.writeVersion;
+            let askQuote, bidQuote;
+            if (eventDriven) {
+                ;
+                [askQuote, bidQuote] = await Promise.all([this.quoteV2(poolInfo, true), this.quoteV2(poolInfo, false)]);
+            }
+            else {
+                ;
+                [askQuote, bidQuote] = await Promise.all([this.quoteV1(poolInfo, true), this.quoteV1(poolInfo, false)]);
+            }
+            trace.mark('compute');
+            const askN = Number(askQuote.price), bidN = Number(bidQuote.price);
+            if (askN > 0 && bidN > 0 && askN < bidN) {
+                throw new Error(`ask(${askN}) < bid(${bidN}) — 异常价差，丢弃该报价`);
+            }
+            this.poolLastQuoteTimeMap.set(pool_address, Date.now());
+            stage = 'depth';
+            const t0a = poolInfo.tokenA?.address, t1a = poolInfo.tokenB?.address;
+            const priceMap = (t0a && t1a) ? await this.chain.loadTokenPrices([t0a, t1a]) : new Map();
+            const depth = await this.calculateDepth(poolInfo, pool_address, priceMap);
+            trace.mark('depth');
+            trace.set('ask', askQuote.price);
+            trace.set('bid', bidQuote.price);
+            trace.set('tiers', depth?.ask?.tiers?.length ?? 0);
+            trace.set('quote_amount_usd', quote_amount_usd);
+            trace.set('txid', txid);
+            return { poolInfo, quote_amount_usd, streamTimestamp, quoteStartTime, blockNumber, txIndex, askQuote, bidQuote, txid, source, depth, priceMap, trace };
+        }
+        catch (error) {
+            trace.markError(stage, error instanceof Error ? error.message : String(error));
+            trace.flush();
+            return null;
+        }
+    }
+    publishQuote(result) {
+        const poolAddr = result.poolInfo.pool_address;
+        const isV2 = result.source?.endsWith(':v2');
+        let shouldPush = true;
+        if (result.source?.endsWith(':v1')) {
+            shouldPush = true;
+        }
+        else {
+            const incomingTx = result.txIndex;
+            if (!Number.isInteger(incomingTx)) {
+                shouldPush = true;
+            }
+            else {
+                const tx = incomingTx;
+                shouldPush = !this.isStaleUpdate(poolAddr, result.blockNumber, tx);
+                if (shouldPush)
+                    this.lastPublished.set(poolAddr, { block: result.blockNumber, txIndex: tx });
+            }
+        }
+        if (shouldPush) {
+            (0, dist_1.on_quote_response)({
+                appConfig: this.appConfig, poolInfo: result.poolInfo, quoteAmountUsd: result.quote_amount_usd,
+                streamTime: result.streamTimestamp, quoteStartTime: result.quoteStartTime, blockNumber: result.blockNumber,
+                quotes: [result.askQuote, result.bidQuote], txid: result.txid, source: result.source, depth: result.depth,
+            });
+            if (isV2) {
+                (0, dist_1.log_info)(`[QUOTE OK v2] ${result.poolInfo.pool_name} ask=${result.askQuote.price} bid=${result.bidQuote.price} slot=${result.blockNumber} wv=${result.txIndex ?? '-'} ${result.txid}`);
+            }
+        }
+        result.trace?.set('published', shouldPush);
+        result.trace?.mark('publish');
+        const candidateTiers = isV2 && result.depth ? {
+            ask_tiers: result.depth.ask.tiers.map(t => ({ pct: t.pct, price: t.price, amount: t.amount, amount_in: t.amount_in })),
+            bid_tiers: result.depth.bid.tiers.map(t => ({ pct: t.pct, price: t.price, amount: t.amount, amount_in: t.amount_in })),
+        } : {};
+        (0, dist_1.report_quote_candidate)({
+            pool_address: poolAddr, pair: result.poolInfo.pair, dex_id: result.poolInfo.dex_id,
+            source: result.source || '', block_number: result.blockNumber,
+            ask_price: result.askQuote.price, bid_price: result.bidQuote.price, ...candidateTiers,
+        });
+        const quoteId = result.txid?.slice(0, 10) || `slot:${result.blockNumber}`;
+        const tiersArg = isV2 ? { askTiers: result.depth?.ask?.tiers, bidTiers: result.depth?.bid?.tiers } : undefined;
+        const t0a = result.poolInfo.tokenA?.address, t1a = result.poolInfo.tokenB?.address;
+        const p0 = t0a ? Number(result.priceMap?.get(t0a)?.price) || 0 : 0;
+        const p1 = t1a ? Number(result.priceMap?.get(t1a)?.price) || 0 : 0;
+        this.quotePriceVerify.cacheQuote(poolAddr, quoteId, result.source || '', Number(result.askQuote.price), Number(result.bidQuote.price), result.blockNumber, result.quote_amount_usd, p0, p1, tiersArg);
+        result.trace?.mark('verify');
+        result.trace?.flush();
+    }
+}
+exports.AbstractDexQuote = AbstractDexQuote;

package/dist/quote/chain_ops.d.ts

@@ -0,0 +1,18 @@
+import { AppConfig, CHAIN_ID, StandardPoolInfoType } from '@clonegod/ttd-core/dist';
+import { Connection } from '@solana/web3.js';
+import { SolPoolEvent } from './pool_event';
+import { TokenPriceCache } from './pricing/token_price_cache';
+export declare class SolanaChainOps {
+    private readonly appConfig;
+    private readonly connection;
+    private readonly tokenPriceCache;
+    readonly chainId = CHAIN_ID.SOLANA;
+    constructor(appConfig: AppConfig, connection: Connection, tokenPriceCache: TokenPriceCache);
+    isValidPoolAddress(addr: string): boolean;
+    assertProgramDeployed(programAddress: string): Promise<void>;
+    loadTokenPrices(addresses: string[]): Promise<Map<string, {
+        price: string;
+    } | undefined>>;
+    subscribeNewBlock(handler: (raw: string) => void): void;
+    subscribePoolEvents(dexId: string, pools: StandardPoolInfoType[], handler: (evt: SolPoolEvent) => void): void;
+}

package/dist/quote/chain_ops.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaChainOps = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const web3_js_1 = require("@solana/web3.js");
+const subscribe_account_update_1 = require("../common/subscribe_account_update");
+const pool_event_1 = require("./pool_event");
+class SolanaChainOps {
+    constructor(appConfig, connection, tokenPriceCache) {
+        this.appConfig = appConfig;
+        this.connection = connection;
+        this.tokenPriceCache = tokenPriceCache;
+        this.chainId = dist_1.CHAIN_ID.SOLANA;
+    }
+    isValidPoolAddress(addr) {
+        try {
+            new web3_js_1.PublicKey(addr);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async assertProgramDeployed(programAddress) {
+        if (!programAddress)
+            return;
+        const info = await this.connection.getAccountInfo(new web3_js_1.PublicKey(programAddress));
+        if (!info) {
+            throw new Error(`[chain-ops] program ${programAddress} 在本链不存在（getAccountInfo=null）—— 疑似抄错地址/抄别链`);
+        }
+        if (!info.executable) {
+            throw new Error(`[chain-ops] account ${programAddress} 非 executable program —— 疑似把数据账户当 program`);
+        }
+    }
+    async loadTokenPrices(addresses) {
+        const out = new Map();
+        await Promise.all(addresses.map(async (addr) => {
+            try {
+                const p = await this.tokenPriceCache.getTokenPrice(addr);
+                out.set(addr, { price: p.price });
+            }
+            catch {
+                out.set(addr, undefined);
+            }
+        }));
+        return out;
+    }
+    subscribeNewBlock(handler) {
+        this.appConfig.arb_event_subscriber.subscribe_new_block(this.chainId, handler);
+    }
+    subscribePoolEvents(dexId, pools, handler) {
+        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) => {
+            try {
+                if (!poolSet.has(data.pool_address))
+                    return;
+                handler((0, pool_event_1.toSolPoolEvent)(data));
+            }
+            catch (e) {
+                (0, dist_1.log_warn)(`[SolanaChainOps] bad pool account update`, data);
+            }
+        });
+    }
+}
+exports.SolanaChainOps = SolanaChainOps;

package/dist/quote/depth/clmm_depth_calculator.d.ts

@@ -0,0 +1,42 @@
+export interface DepthTick {
+    index: number;
+    liquidityNet: bigint;
+    sqrtPriceX64: bigint;
+}
+export interface ClmmDepthInput {
+    sqrtPriceX64: bigint;
+    currentTick: number;
+    liquidity: bigint;
+    ticks: DepthTick[];
+    zeroForOne: boolean;
+    targetBps: number;
+    inputDecimals: number;
+    outputDecimals: number;
+}
+export interface DepthResult {
+    amountInWei: bigint;
+    amountIn: number;
+    amountOutWei: bigint;
+    amountOut: number;
+    currentTick: number;
+    targetTick: number;
+    targetSqrtPriceX64: bigint;
+}
+export declare function calculateClmmDepth(input: ClmmDepthInput): DepthResult;
+export declare function priceFromSqrtX64(sqrtPriceX64: bigint, baseDecimals: number, quoteDecimals: number, baseIsToken0: boolean): number;
+export declare function computeTargetSqrtX64(currentSqrtPriceX64: bigint, bps: number, zeroForOne: boolean): bigint;
+export declare function bigIntSqrt(n: bigint): bigint;
+export interface SwapExactInInput {
+    sqrtPriceX64: bigint;
+    currentTick: number;
+    liquidity: bigint;
+    ticks: DepthTick[];
+    zeroForOne: boolean;
+    amountInNetWei: bigint;
+}
+export interface SwapExactInResult {
+    amountInConsumedWei: bigint;
+    amountOutWei: bigint;
+    endSqrtPriceX64: bigint;
+}
+export declare function swapExactInClmm(input: SwapExactInInput): SwapExactInResult;

package/dist/quote/depth/clmm_depth_calculator.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateClmmDepth = calculateClmmDepth;
+exports.priceFromSqrtX64 = priceFromSqrtX64;
+exports.computeTargetSqrtX64 = computeTargetSqrtX64;
+exports.bigIntSqrt = bigIntSqrt;
+exports.swapExactInClmm = swapExactInClmm;
+const Q64 = 1n << 64n;
+function calculateClmmDepth(input) {
+    const { currentTick, zeroForOne, targetBps, inputDecimals, outputDecimals } = input;
+    const currentSqrtPriceX64 = input.sqrtPriceX64;
+    let liquidity = input.liquidity;
+    if (liquidity <= 0n) {
+        return { amountInWei: 0n, amountIn: 0, amountOutWei: 0n, amountOut: 0, currentTick, targetTick: currentTick, targetSqrtPriceX64: currentSqrtPriceX64 };
+    }
+    const targetSqrtPriceX64 = computeTargetSqrtX64(currentSqrtPriceX64, targetBps, zeroForOne);
+    const ticksToTraverse = getTicksBetween(input.ticks, currentTick, zeroForOne);
+    let totalInput = 0n;
+    let totalOutput = 0n;
+    let sqrtPriceCursor = currentSqrtPriceX64;
+    for (const tick of ticksToTraverse) {
+        const sqrtPriceAtTick = tick.sqrtPriceX64;
+        if (zeroForOne && sqrtPriceAtTick <= targetSqrtPriceX64)
+            break;
+        if (!zeroForOne && sqrtPriceAtTick >= targetSqrtPriceX64)
+            break;
+        if (liquidity > 0n) {
+            totalInput += calcInputForRange(sqrtPriceCursor, sqrtPriceAtTick, liquidity, zeroForOne);
+            totalOutput += calcOutputForRange(sqrtPriceCursor, sqrtPriceAtTick, liquidity, zeroForOne);
+        }
+        let liquidityNet = tick.liquidityNet;
+        if (zeroForOne)
+            liquidityNet = -liquidityNet;
+        liquidity = liquidity + liquidityNet;
+        if (liquidity < 0n)
+            liquidity = 0n;
+        sqrtPriceCursor = sqrtPriceAtTick;
+    }
+    if (liquidity > 0n && sqrtPriceCursor !== targetSqrtPriceX64) {
+        totalInput += calcInputForRange(sqrtPriceCursor, targetSqrtPriceX64, liquidity, zeroForOne);
+        totalOutput += calcOutputForRange(sqrtPriceCursor, targetSqrtPriceX64, liquidity, zeroForOne);
+    }
+    const amountIn = Number(totalInput) / Math.pow(10, inputDecimals);
+    const amountOut = Number(totalOutput) / Math.pow(10, outputDecimals);
+    const sqrtPriceFloat = Number(targetSqrtPriceX64) / Number(Q64);
+    const targetTick = Math.floor(Math.log(sqrtPriceFloat * sqrtPriceFloat) / Math.log(1.0001));
+    return { amountInWei: totalInput, amountIn, amountOutWei: totalOutput, amountOut, currentTick, targetTick, targetSqrtPriceX64 };
+}
+function priceFromSqrtX64(sqrtPriceX64, baseDecimals, quoteDecimals, baseIsToken0) {
+    const sp = Number(sqrtPriceX64) / Number(Q64);
+    const priceToken1PerToken0 = sp * sp;
+    if (baseIsToken0) {
+        return priceToken1PerToken0 * Math.pow(10, baseDecimals - quoteDecimals);
+    }
+    else {
+        return (1 / priceToken1PerToken0) * Math.pow(10, baseDecimals - quoteDecimals);
+    }
+}
+function computeTargetSqrtX64(currentSqrtPriceX64, bps, zeroForOne) {
+    const PRECISION = 10n ** 18n;
+    const bpsBigInt = BigInt(bps);
+    const factor = zeroForOne ? 10000n - bpsBigInt : 10000n + bpsBigInt;
+    const sqrtFactor = bigIntSqrt(factor * PRECISION);
+    const sqrtBase = bigIntSqrt(10000n * PRECISION);
+    return currentSqrtPriceX64 * sqrtFactor / sqrtBase;
+}
+function bigIntSqrt(n) {
+    if (n < 0n)
+        throw new Error('sqrt of negative');
+    if (n === 0n)
+        return 0n;
+    if (n <= 3n)
+        return 1n;
+    let x = n;
+    let y = (x + 1n) / 2n;
+    while (y < x) {
+        x = y;
+        y = (x + n / x) / 2n;
+    }
+    return x;
+}
+function getTicksBetween(ticks, currentTick, zeroForOne) {
+    if (zeroForOne) {
+        return ticks.filter(t => t.index <= currentTick).sort((a, b) => b.index - a.index);
+    }
+    else {
+        return ticks.filter(t => t.index > currentTick).sort((a, b) => a.index - b.index);
+    }
+}
+function nextSqrtFromAmountIn(sqrtPriceX64, liquidity, amountIn, zeroForOne) {
+    if (amountIn <= 0n || liquidity <= 0n)
+        return sqrtPriceX64;
+    if (zeroForOne) {
+        const numerator = liquidity * sqrtPriceX64 * Q64;
+        const denominator = liquidity * Q64 + amountIn * sqrtPriceX64;
+        return numerator / denominator;
+    }
+    else {
+        return sqrtPriceX64 + (amountIn * Q64) / liquidity;
+    }
+}
+function swapExactInClmm(input) {
+    const { currentTick, zeroForOne } = input;
+    let liquidity = input.liquidity;
+    let sqrtCursor = input.sqrtPriceX64;
+    let remaining = input.amountInNetWei;
+    let totalOut = 0n;
+    let consumed = 0n;
+    if (liquidity <= 0n || remaining <= 0n) {
+        return { amountInConsumedWei: 0n, amountOutWei: 0n, endSqrtPriceX64: sqrtCursor };
+    }
+    const ticksToTraverse = getTicksBetween(input.ticks, currentTick, zeroForOne);
+    for (const tick of ticksToTraverse) {
+        if (remaining <= 0n)
+            break;
+        const sqrtAtTick = tick.sqrtPriceX64;
+        if (liquidity > 0n) {
+            const segMaxIn = calcInputForRange(sqrtCursor, sqrtAtTick, liquidity, zeroForOne);
+            if (remaining < segMaxIn) {
+                const nextSqrt = nextSqrtFromAmountIn(sqrtCursor, liquidity, remaining, zeroForOne);
+                totalOut += calcOutputForRange(sqrtCursor, nextSqrt, liquidity, zeroForOne);
+                consumed += remaining;
+                remaining = 0n;
+                sqrtCursor = nextSqrt;
+                break;
+            }
+            totalOut += calcOutputForRange(sqrtCursor, sqrtAtTick, liquidity, zeroForOne);
+            consumed += segMaxIn;
+            remaining -= segMaxIn;
+        }
+        sqrtCursor = sqrtAtTick;
+        let liquidityNet = tick.liquidityNet;
+        if (zeroForOne)
+            liquidityNet = -liquidityNet;
+        liquidity = liquidity + liquidityNet;
+        if (liquidity < 0n)
+            liquidity = 0n;
+    }
+    if (remaining > 0n && liquidity > 0n) {
+        const nextSqrt = nextSqrtFromAmountIn(sqrtCursor, liquidity, remaining, zeroForOne);
+        totalOut += calcOutputForRange(sqrtCursor, nextSqrt, liquidity, zeroForOne);
+        consumed += remaining;
+        sqrtCursor = nextSqrt;
+        remaining = 0n;
+    }
+    return { amountInConsumedWei: consumed, amountOutWei: totalOut, endSqrtPriceX64: sqrtCursor };
+}
+function calcInputForRange(sqrtPriceA, sqrtPriceB, liquidity, zeroForOne) {
+    const lower = sqrtPriceA < sqrtPriceB ? sqrtPriceA : sqrtPriceB;
+    const upper = sqrtPriceA < sqrtPriceB ? sqrtPriceB : sqrtPriceA;
+    const diff = upper - lower;
+    if (diff === 0n || liquidity === 0n)
+        return 0n;
+    if (zeroForOne) {
+        return liquidity * diff * Q64 / (lower * upper);
+    }
+    else {
+        return liquidity * diff / Q64;
+    }
+}
+function calcOutputForRange(sqrtPriceA, sqrtPriceB, liquidity, zeroForOne) {
+    const lower = sqrtPriceA < sqrtPriceB ? sqrtPriceA : sqrtPriceB;
+    const upper = sqrtPriceA < sqrtPriceB ? sqrtPriceB : sqrtPriceA;
+    const diff = upper - lower;
+    if (diff === 0n || liquidity === 0n)
+        return 0n;
+    if (zeroForOne) {
+        return liquidity * diff / Q64;
+    }
+    else {
+        return liquidity * diff * Q64 / (lower * upper);
+    }
+}

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

@@ -0,0 +1,20 @@
+import { StandardPoolInfoType } from '@clonegod/ttd-core/dist';
+import { QuoteDepthOutput } from '@clonegod/ttd-core/dist';
+import { DepthTick } from './clmm_depth_calculator';
+export { calculateClmmDepth, priceFromSqrtX64, computeTargetSqrtX64, bigIntSqrt, swapExactInClmm } from './clmm_depth_calculator';
+export type { DepthTick, ClmmDepthInput, DepthResult, SwapExactInInput, SwapExactInResult } from './clmm_depth_calculator';
+export interface BuildClmmDepthInput {
+    poolInfo: StandardPoolInfoType;
+    poolAddress: string;
+    poolState: {
+        currentSqrtPriceX64: bigint;
+        currentTick: number;
+        liquidity: bigint;
+        baseIsToken0: boolean;
+    };
+    ticks: DepthTick[];
+    basePriceUsd: number;
+    quotePriceUsd: number;
+    feeRateBps: number;
+}
+export declare function buildClmmDepth(input: BuildClmmDepthInput): QuoteDepthOutput | undefined;

package/dist/quote/depth/index.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swapExactInClmm = exports.bigIntSqrt = exports.computeTargetSqrtX64 = exports.priceFromSqrtX64 = exports.calculateClmmDepth = void 0;
+exports.buildClmmDepth = buildClmmDepth;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const dist_2 = require("@clonegod/ttd-core/dist");
+const trade_direction_1 = require("../../utils/trade_direction");
+const clmm_depth_calculator_1 = require("./clmm_depth_calculator");
+var clmm_depth_calculator_2 = require("./clmm_depth_calculator");
+Object.defineProperty(exports, "calculateClmmDepth", { enumerable: true, get: function () { return clmm_depth_calculator_2.calculateClmmDepth; } });
+Object.defineProperty(exports, "priceFromSqrtX64", { enumerable: true, get: function () { return clmm_depth_calculator_2.priceFromSqrtX64; } });
+Object.defineProperty(exports, "computeTargetSqrtX64", { enumerable: true, get: function () { return clmm_depth_calculator_2.computeTargetSqrtX64; } });
+Object.defineProperty(exports, "bigIntSqrt", { enumerable: true, get: function () { return clmm_depth_calculator_2.bigIntSqrt; } });
+Object.defineProperty(exports, "swapExactInClmm", { enumerable: true, get: function () { return clmm_depth_calculator_2.swapExactInClmm; } });
+let _depthPctLogged = false;
+function logDepthLevelsOnce() {
+    if (_depthPctLogged)
+        return;
+    _depthPctLogged = true;
+    (0, dist_1.log_info)(`[Depth] pctLevels=${JSON.stringify((0, dist_2.getDepthPricePctLevels)())}, default=${dist_2.DEFAULT_TIER_PCT}`);
+}
+function grossUpFee(amountInNet, feeRateBps) {
+    if (feeRateBps <= 0 || amountInNet <= 0)
+        return { amountInGross: amountInNet, feeAmount: 0 };
+    const feeRatio = feeRateBps / 10000;
+    const amountInGross = amountInNet / (1 - feeRatio);
+    return { amountInGross, feeAmount: amountInGross - amountInNet };
+}
+function assembleEntry(tiers) {
+    const def = tiers.find(t => t.pct === dist_2.DEFAULT_TIER_PCT) ?? tiers[0];
+    return {
+        price: def.price, amount: def.amount, amount_in: def.amount_in, amount_in_usd: def.amount_in_usd,
+        fee: def.fee, fee_usd: def.fee_usd, tick_move: def.tick_move, tiers,
+    };
+}
+function buildClmmDepth(input) {
+    logDepthLevelsOnce();
+    const pctLevels = (0, dist_2.getDepthPricePctLevels)();
+    if (pctLevels.length === 0)
+        return undefined;
+    const { poolInfo, poolState, ticks, basePriceUsd, quotePriceUsd, feeRateBps } = input;
+    if (poolState.liquidity <= 0n)
+        return undefined;
+    if (feeRateBps == null || feeRateBps < 0) {
+        (0, dist_1.log_debug)(`[Depth] ${poolInfo.pool_name} CLMM: invalid feeRateBps=${feeRateBps}, skip`, '');
+        return undefined;
+    }
+    try {
+        const dir = (0, trade_direction_1.resolveTradeDirection)(poolInfo, true);
+        const baseToken = dir.baseToken;
+        const quoteToken = dir.quoteToken;
+        const baseIsToken0 = poolState.baseIsToken0;
+        const askZeroForOne = !baseIsToken0;
+        const bidZeroForOne = baseIsToken0;
+        const midPrice = (0, clmm_depth_calculator_1.priceFromSqrtX64)(poolState.currentSqrtPriceX64, baseToken.decimals, quoteToken.decimals, baseIsToken0);
+        const askTiers = [];
+        const bidTiers = [];
+        for (const pct of pctLevels) {
+            const bps = Math.round(pct * 100);
+            const askResult = (0, clmm_depth_calculator_1.calculateClmmDepth)({
+                sqrtPriceX64: poolState.currentSqrtPriceX64, currentTick: poolState.currentTick,
+                liquidity: poolState.liquidity, ticks, zeroForOne: askZeroForOne, targetBps: bps,
+                inputDecimals: quoteToken.decimals, outputDecimals: baseToken.decimals,
+            });
+            const bidResult = (0, clmm_depth_calculator_1.calculateClmmDepth)({
+                sqrtPriceX64: poolState.currentSqrtPriceX64, currentTick: poolState.currentTick,
+                liquidity: poolState.liquidity, ticks, zeroForOne: bidZeroForOne, targetBps: bps,
+                inputDecimals: baseToken.decimals, outputDecimals: quoteToken.decimals,
+            });
+            const askTargetPrice = (0, clmm_depth_calculator_1.priceFromSqrtX64)(askResult.targetSqrtPriceX64, baseToken.decimals, quoteToken.decimals, baseIsToken0);
+            const bidTargetPrice = (0, clmm_depth_calculator_1.priceFromSqrtX64)(bidResult.targetSqrtPriceX64, baseToken.decimals, quoteToken.decimals, baseIsToken0);
+            const askGross = grossUpFee(askResult.amountIn, feeRateBps);
+            const bidGross = grossUpFee(bidResult.amountIn, feeRateBps);
+            const askTickMove = `${askResult.targetTick} <- ${askResult.currentTick}`;
+            const bidTickMove = `${bidResult.currentTick} -> ${bidResult.targetTick}`;
+            const askEffPrice = askResult.amountOut > 0 ? askGross.amountInGross / askResult.amountOut : askTargetPrice;
+            const bidEffPrice = bidGross.amountInGross > 0 ? bidResult.amountOut / bidGross.amountInGross : bidTargetPrice;
+            askTiers.push({
+                pct, price: askEffPrice, amount: askResult.amountOut,
+                amount_in: askGross.amountInGross, amount_in_usd: askGross.amountInGross * quotePriceUsd,
+                fee: askGross.feeAmount, fee_usd: askGross.feeAmount * quotePriceUsd, tick_move: askTickMove,
+            });
+            bidTiers.push({
+                pct, price: bidEffPrice, amount: bidResult.amountOut,
+                amount_in: bidGross.amountInGross, amount_in_usd: bidGross.amountInGross * basePriceUsd,
+                fee: bidGross.feeAmount, fee_usd: bidGross.feeAmount * basePriceUsd, tick_move: bidTickMove,
+            });
+        }
+        return {
+            mid_price: midPrice,
+            fee_rate_bps: feeRateBps,
+            ask: assembleEntry(askTiers),
+            bid: assembleEntry(bidTiers),
+        };
+    }
+    catch (error) {
+        (0, dist_1.log_debug)(`[Depth] ${poolInfo.pool_name} CLMM depth failed: ${error.message}`, '');
+        return undefined;
+    }
+}

package/dist/quote/index.d.ts

@@ -1 +1,10 @@
 export * from './pricing';
+export * from './pool_subscription_registry';
+export * from './pool_event';
+export * from './chain_ops';
+export * from './abstract_dex_quote';
+export * from './quote_trace';
+export * from './quote_amount';
+export * from './verify';
+export * from './depth';
+export * from './tick';

package/dist/quote/index.js

@@ -15,3 +15,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./pricing"), exports);
+__exportStar(require("./pool_subscription_registry"), exports);
+__exportStar(require("./pool_event"), exports);
+__exportStar(require("./chain_ops"), exports);
+__exportStar(require("./abstract_dex_quote"), exports);
+__exportStar(require("./quote_trace"), exports);
+__exportStar(require("./quote_amount"), exports);
+__exportStar(require("./verify"), exports);
+__exportStar(require("./depth"), exports);
+__exportStar(require("./tick"), exports);