@clonegod/ttd-sui-common 1.0.101 → 2.0.1

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_v3_engine.d.ts

@@ -0,0 +1,32 @@
+import BN from 'bn.js';
+export type ComputeSwapStepFn = (currentSqrtPrice: BN, targetSqrtPrice: BN, liquidity: BN, amount: BN, feeRate: BN, byAmountIn: boolean) => {
+    amountIn: BN;
+    amountOut: BN;
+    nextSqrtPrice: BN;
+    feeAmount: BN;
+};
+export interface V3StepMath {
+    computeSwapStep: ComputeSwapStepFn;
+    minSqrtPrice: BN;
+    maxSqrtPrice: BN;
+}
+export interface V3PoolState {
+    currentSqrtPrice: BN;
+    currentTickIndex: number;
+    liquidity: BN;
+    feeRate: BN;
+}
+export interface V3Tick {
+    index: number;
+    sqrtPrice: BN;
+    liquidityNet: BN;
+}
+export interface V3SwapResult {
+    amountIn: BN;
+    amountOut: BN;
+    feeAmount: BN;
+    endSqrtPrice: BN;
+    isExceed: boolean;
+    crossTickNum: number;
+}
+export declare function computeSwapV3(aToB: boolean, byAmountIn: boolean, amount: BN, pool: V3PoolState, ticks: V3Tick[], math: V3StepMath): V3SwapResult;

package/dist/quote/tick/clmm_v3_engine.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeSwapV3 = computeSwapV3;
+const bn_js_1 = __importDefault(require("bn.js"));
+const ZERO = new bn_js_1.default(0);
+function computeSwapV3(aToB, byAmountIn, amount, pool, ticks, math) {
+    const sorted = ticks.slice().sort((a, b) => aToB ? b.index - a.index : a.index - b.index);
+    const limit = aToB ? math.minSqrtPrice : math.maxSqrtPrice;
+    let remainer = amount;
+    let liq = pool.liquidity;
+    let curSqrt = pool.currentSqrtPrice;
+    let amountIn = ZERO, amountOut = ZERO, feeAmount = ZERO, crossTickNum = 0;
+    for (const tick of sorted) {
+        if (aToB && pool.currentTickIndex < tick.index)
+            continue;
+        if (!aToB && pool.currentTickIndex >= tick.index)
+            continue;
+        const target = (aToB && limit.gt(tick.sqrtPrice)) || (!aToB && limit.lt(tick.sqrtPrice)) ? limit : tick.sqrtPrice;
+        const step = math.computeSwapStep(curSqrt, target, liq, remainer, pool.feeRate, byAmountIn);
+        if (!step.amountIn.eq(ZERO)) {
+            remainer = byAmountIn ? remainer.sub(step.amountIn.add(step.feeAmount)) : remainer.sub(step.amountOut);
+        }
+        amountIn = amountIn.add(step.amountIn);
+        amountOut = amountOut.add(step.amountOut);
+        feeAmount = feeAmount.add(step.feeAmount);
+        if (step.nextSqrtPrice.eq(tick.sqrtPrice)) {
+            liq = aToB ? liq.sub(tick.liquidityNet) : liq.add(tick.liquidityNet);
+            curSqrt = tick.sqrtPrice;
+        }
+        else {
+            curSqrt = step.nextSqrtPrice;
+        }
+        crossTickNum++;
+        if (remainer.eq(ZERO))
+            break;
+    }
+    return {
+        amountIn: amountIn.add(feeAmount),
+        amountOut,
+        feeAmount,
+        endSqrtPrice: curSqrt,
+        isExceed: remainer.gt(ZERO),
+        crossTickNum,
+    };
+}

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

@@ -0,0 +1,4 @@
+export * from './local_clmm_state';
+export * from './sui_clmm_tick_cache';
+export * from './sui_tick_data_provider';
+export * from './clmm_v3_engine';

package/dist/quote/tick/index.js

@@ -0,0 +1,20 @@
+"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("./local_clmm_state"), exports);
+__exportStar(require("./sui_clmm_tick_cache"), exports);
+__exportStar(require("./sui_tick_data_provider"), exports);
+__exportStar(require("./clmm_v3_engine"), exports);

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

@@ -0,0 +1,17 @@
+export interface LocalClmmState {
+    poolAddress: string;
+    coinTypeA: string;
+    coinTypeB: string;
+    feeRate: number;
+    tickSpacing: number;
+    currentSqrtPrice: string;
+    currentTickIndex: number;
+    liquidity: string;
+    raw?: any;
+}
+export declare function applySwapToState(state: LocalClmmState, afterSqrtPrice: string, tick: number, liquidity: string, rawFieldMap: {
+    sqrtPrice: string;
+    tickIndex: string;
+    liquidity: string;
+}): void;
+export declare function applyLiquidityToActiveState(state: LocalClmmState, tickLower: number, tickUpper: number, signedDelta: bigint, rawLiquidityField: string): void;

package/dist/quote/tick/local_clmm_state.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySwapToState = applySwapToState;
+exports.applyLiquidityToActiveState = applyLiquidityToActiveState;
+function applySwapToState(state, afterSqrtPrice, tick, liquidity, rawFieldMap) {
+    state.currentSqrtPrice = afterSqrtPrice;
+    state.currentTickIndex = tick;
+    state.liquidity = liquidity;
+    if (state.raw) {
+        state.raw[rawFieldMap.sqrtPrice] = afterSqrtPrice;
+        state.raw[rawFieldMap.tickIndex] = tick;
+        state.raw[rawFieldMap.liquidity] = liquidity;
+    }
+}
+function applyLiquidityToActiveState(state, tickLower, tickUpper, signedDelta, rawLiquidityField) {
+    if (tickLower <= state.currentTickIndex && state.currentTickIndex < tickUpper) {
+        const next = BigInt(state.liquidity) + signedDelta;
+        state.liquidity = (next < 0n ? 0n : next).toString();
+        if (state.raw)
+            state.raw[rawLiquidityField] = state.liquidity;
+    }
+}

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

@@ -0,0 +1,42 @@
+export declare const TICK_REFRESH_INTERVAL_MS: number;
+export interface TickInfo {
+    liquidityNet: bigint;
+    liquidityGross: bigint;
+    sqrtPrice?: bigint;
+}
+export interface SuiClmmTickCacheConfig {
+    refreshInterval?: number;
+    minUpdateInterval?: number;
+}
+export interface SuiTickLoader {
+    loadTicks(poolAddress: string): Promise<Map<number, TickInfo>>;
+}
+export declare class SuiClmmTickCache {
+    private pools;
+    private refreshTimers;
+    private loadPromises;
+    private loader;
+    private config;
+    constructor(loader: SuiTickLoader, config?: SuiClmmTickCacheConfig);
+    initPool(poolAddress: string, currentTick: number, tickSpacing: number): Promise<void>;
+    onSwap(poolAddress: string, newTick: number): void;
+    onAdd(poolAddress: string, tickLower: number, tickUpper: number, amount: bigint): void;
+    onRemove(poolAddress: string, tickLower: number, tickUpper: number, amount: bigint): void;
+    private applyLiquidityDelta;
+    private updateTickLiquidity;
+    getTickInfo(poolAddress: string, tickIndex: number): TickInfo | undefined;
+    getSortedTicks(poolAddress: string): {
+        index: number;
+        liquidityNet: bigint;
+        liquidityGross: bigint;
+        sqrtPrice?: bigint;
+    }[];
+    computeActiveLiquidity(poolAddress: string, currentTick: number): bigint;
+    getTickSpacing(poolAddress: string): number | undefined;
+    hasPool(poolAddress: string): boolean;
+    scheduleFullRefresh(poolAddress: string): Promise<void>;
+    private startPeriodicRefresh;
+    private doFullRefresh;
+    clearPool(poolAddress: string): void;
+    destroy(): void;
+}

package/dist/quote/tick/sui_clmm_tick_cache.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuiClmmTickCache = exports.TICK_REFRESH_INTERVAL_MS = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+exports.TICK_REFRESH_INTERVAL_MS = Number(process.env.TICK_CACHE_FORCE_FULL_REFRESH_INTERVAL) || 60000;
+class SuiClmmTickCache {
+    constructor(loader, config = {}) {
+        this.pools = new Map();
+        this.refreshTimers = new Map();
+        this.loadPromises = new Map();
+        this.loader = loader;
+        this.config = {
+            refreshInterval: config.refreshInterval ?? exports.TICK_REFRESH_INTERVAL_MS,
+            minUpdateInterval: config.minUpdateInterval ?? (Number(process.env.TICK_CACHE_MIN_UPDATE_INTERVAL) || 3000),
+        };
+    }
+    async initPool(poolAddress, currentTick, tickSpacing) {
+        const ticks = await this.loader.loadTicks(poolAddress);
+        this.pools.set(poolAddress, {
+            ticks,
+            currentTick,
+            tickSpacing,
+            lastFullLoadTime: Date.now(),
+            loading: false,
+            pendingForceRefresh: false,
+        });
+        this.startPeriodicRefresh(poolAddress);
+        (0, ttd_core_1.log_info)(`[SuiTickCache] Pool ${poolAddress} initialized: ${ticks.size} ticks, tick=${currentTick}, spacing=${tickSpacing}`);
+    }
+    onSwap(poolAddress, newTick) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return;
+        state.currentTick = newTick;
+    }
+    onAdd(poolAddress, tickLower, tickUpper, amount) {
+        this.applyLiquidityDelta(poolAddress, tickLower, tickUpper, amount);
+    }
+    onRemove(poolAddress, tickLower, tickUpper, amount) {
+        this.applyLiquidityDelta(poolAddress, tickLower, tickUpper, -amount);
+    }
+    applyLiquidityDelta(poolAddress, tickLower, tickUpper, delta) {
+        const state = this.pools.get(poolAddress);
+        if (!state) {
+            (0, ttd_core_1.log_warn)(`[SuiTickCache] Pool ${poolAddress} not initialized, ignoring liquidity event`, '');
+            return;
+        }
+        const absDelta = delta < 0n ? -delta : delta;
+        this.updateTickLiquidity(state, tickLower, delta, absDelta);
+        this.updateTickLiquidity(state, tickUpper, -delta, absDelta);
+        (0, ttd_core_1.log_debug)(`[SuiTickCache] ${poolAddress}: delta applied tickLower=${tickLower} tickUpper=${tickUpper} delta=${delta}`);
+    }
+    updateTickLiquidity(state, tickIndex, netDelta, grossDelta) {
+        const existing = state.ticks.get(tickIndex);
+        if (existing) {
+            existing.liquidityNet += netDelta;
+            existing.liquidityGross += (netDelta > 0n ? grossDelta : -grossDelta);
+            if (existing.liquidityGross <= 0n) {
+                state.ticks.delete(tickIndex);
+                (0, ttd_core_1.log_debug)(`[SuiTickCache] Tick ${tickIndex} de-initialized (gross<=0)`);
+            }
+            return;
+        }
+        if (netDelta > 0n || grossDelta > 0n) {
+            state.ticks.set(tickIndex, { liquidityNet: netDelta, liquidityGross: grossDelta });
+            (0, ttd_core_1.log_debug)(`[SuiTickCache] New tick ${tickIndex} initialized`);
+        }
+    }
+    getTickInfo(poolAddress, tickIndex) {
+        return this.pools.get(poolAddress)?.ticks.get(tickIndex);
+    }
+    getSortedTicks(poolAddress) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return [];
+        return Array.from(state.ticks.entries())
+            .map(([index, info]) => ({ index, liquidityNet: info.liquidityNet, liquidityGross: info.liquidityGross, sqrtPrice: info.sqrtPrice }))
+            .sort((a, b) => a.index - b.index);
+    }
+    computeActiveLiquidity(poolAddress, currentTick) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return 0n;
+        let acc = 0n;
+        for (const t of this.getSortedTicks(poolAddress)) {
+            if (t.index > currentTick)
+                break;
+            acc += t.liquidityNet;
+        }
+        return acc < 0n ? 0n : acc;
+    }
+    getTickSpacing(poolAddress) {
+        return this.pools.get(poolAddress)?.tickSpacing;
+    }
+    hasPool(poolAddress) {
+        return this.pools.has(poolAddress);
+    }
+    async scheduleFullRefresh(poolAddress) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return;
+        const existing = this.loadPromises.get(poolAddress);
+        if (existing)
+            return existing;
+        if (Date.now() - state.lastFullLoadTime < this.config.minUpdateInterval)
+            return;
+        const promise = this.doFullRefresh(poolAddress).finally(() => this.loadPromises.delete(poolAddress));
+        this.loadPromises.set(poolAddress, promise);
+        return promise;
+    }
+    startPeriodicRefresh(poolAddress) {
+        const old = this.refreshTimers.get(poolAddress);
+        if (old)
+            clearInterval(old);
+        const timer = setInterval(async () => {
+            try {
+                await this.doFullRefresh(poolAddress);
+            }
+            catch (err) {
+                (0, ttd_core_1.log_warn)(`[SuiTickCache] periodic refresh failed ${poolAddress}: ${err.message}`, '');
+            }
+        }, this.config.refreshInterval);
+        this.refreshTimers.set(poolAddress, timer);
+    }
+    async doFullRefresh(poolAddress) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return;
+        if (state.loading) {
+            state.pendingForceRefresh = true;
+            return;
+        }
+        state.loading = true;
+        try {
+            const ticks = await this.loader.loadTicks(poolAddress);
+            state.ticks = ticks;
+            state.lastFullLoadTime = Date.now();
+            state.pendingForceRefresh = false;
+            (0, ttd_core_1.log_debug)(`[SuiTickCache] full refresh ${poolAddress}: ${ticks.size} ticks`);
+        }
+        finally {
+            state.loading = false;
+            if (state.pendingForceRefresh) {
+                state.pendingForceRefresh = false;
+                this.doFullRefresh(poolAddress).catch(() => { });
+            }
+        }
+    }
+    clearPool(poolAddress) {
+        this.pools.delete(poolAddress);
+        const timer = this.refreshTimers.get(poolAddress);
+        if (timer) {
+            clearInterval(timer);
+            this.refreshTimers.delete(poolAddress);
+        }
+        this.loadPromises.delete(poolAddress);
+    }
+    destroy() {
+        for (const [addr] of this.pools)
+            this.clearPool(addr);
+    }
+}
+exports.SuiClmmTickCache = SuiClmmTickCache;

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

@@ -0,0 +1,2 @@
+import { SuiClmmTickCache } from './sui_clmm_tick_cache';
+export declare function buildSwapTicks<T>(cache: SuiClmmTickCache, poolAddress: string, mkTick: (index: number, liquidityNet: bigint, liquidityGross: bigint, sqrtPrice?: bigint) => T): T[];

package/dist/quote/tick/sui_tick_data_provider.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSwapTicks = buildSwapTicks;
+function buildSwapTicks(cache, poolAddress, mkTick) {
+    return cache.getSortedTicks(poolAddress).map(t => mkTick(t.index, t.liquidityNet, t.liquidityGross, t.sqrtPrice));
+}

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