@clonegod/ttd-sol-common 2.0.67 → 2.0.69

package/dist/quote/depth/index.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateAmmDepth = exports.swapExactInClmm = exports.bigIntSqrt = exports.computeTargetSqrtX64 = exports.priceFromSqrtX64 = exports.calculateClmmDepth = void 0;
+exports.grossUpFee = grossUpFee;
+exports.assembleEntry = assembleEntry;
+exports.buildClmmDepth = buildClmmDepth;
+exports.buildAmmDepth = buildAmmDepth;
+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");
+const amm_depth_calculator_1 = require("./amm_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; } });
+var amm_depth_calculator_2 = require("./amm_depth_calculator");
+Object.defineProperty(exports, "calculateAmmDepth", { enumerable: true, get: function () { return amm_depth_calculator_2.calculateAmmDepth; } });
+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;
+    }
+}
+function buildAmmDepth(input) {
+    logDepthLevelsOnce();
+    const pctLevels = (0, dist_2.getDepthPricePctLevels)();
+    if (pctLevels.length === 0)
+        return undefined;
+    const { poolInfo, reserve0, reserve1, baseIsToken0, basePriceUsd, quotePriceUsd, feeRateBps } = input;
+    if (feeRateBps == null || feeRateBps < 0) {
+        (0, dist_1.log_debug)(`[Depth] ${poolInfo.pool_name} AMM: 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 baseReserveUi = Number(BigInt(baseIsToken0 ? reserve0 : reserve1)) / Math.pow(10, baseToken.decimals);
+        const quoteReserveUi = Number(BigInt(baseIsToken0 ? reserve1 : reserve0)) / Math.pow(10, quoteToken.decimals);
+        const midPrice = quoteReserveUi / baseReserveUi;
+        const askTiers = [];
+        const bidTiers = [];
+        for (const pct of pctLevels) {
+            const bps = Math.round(pct * 100);
+            const askResult = (0, amm_depth_calculator_1.calculateAmmDepth)({
+                reserve0, reserve1, targetBps: bps, isBuy: true, baseIsToken0,
+                token0Decimals: baseIsToken0 ? baseToken.decimals : quoteToken.decimals,
+                token1Decimals: baseIsToken0 ? quoteToken.decimals : baseToken.decimals,
+            });
+            const bidResult = (0, amm_depth_calculator_1.calculateAmmDepth)({
+                reserve0, reserve1, targetBps: bps, isBuy: false, baseIsToken0,
+                token0Decimals: baseIsToken0 ? baseToken.decimals : quoteToken.decimals,
+                token1Decimals: baseIsToken0 ? quoteToken.decimals : baseToken.decimals,
+            });
+            const askGross = grossUpFee(askResult.amountIn, feeRateBps);
+            const bidGross = grossUpFee(bidResult.amountIn, feeRateBps);
+            const askEffPrice = askResult.amountOut > 0 ? askGross.amountInGross / askResult.amountOut : askResult.targetPrice;
+            const bidEffPrice = bidGross.amountInGross > 0 ? bidResult.amountOut / bidGross.amountInGross : bidResult.targetPrice;
+            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,
+            });
+            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,
+            });
+        }
+        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} AMM 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);

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;
+}