@clonegod/ttd-bsc-common 1.0.89 → 2.0.1

package/dist/quote/tick/clmm_tick_cache.js

@@ -0,0 +1,219 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClmmTickCache = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+class ClmmTickCache {
+    constructor(loader, config = {}) {
+        var _a, _b, _c;
+        this.pools = new Map();
+        this.refreshTimers = new Map();
+        this.loadPromises = new Map();
+        this.loader = loader;
+        this.config = {
+            neighboringWords: (_a = config.neighboringWords) !== null && _a !== void 0 ? _a : 2,
+            refreshInterval: (_b = config.refreshInterval) !== null && _b !== void 0 ? _b : 30000,
+            minUpdateInterval: (_c = config.minUpdateInterval) !== null && _c !== void 0 ? _c : 3000,
+        };
+    }
+    initPool(poolAddress, currentTick, tickSpacing) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bitmapIndexes = this.calcBitmapIndexes(currentTick, tickSpacing);
+            (0, dist_1.log_info)(`[TickCache] Init pool ${poolAddress}: tick=${currentTick}, tickSpacing=${tickSpacing}, loading ${bitmapIndexes.length} bitmap words`);
+            const ticks = yield this.loader.loadBitmapWords(poolAddress, bitmapIndexes);
+            this.pools.set(poolAddress, {
+                ticks,
+                bitmapIndexes,
+                currentTick,
+                tickSpacing,
+                lastFullLoadTime: Date.now(),
+                pendingForceRefresh: false,
+                loading: false,
+            });
+            this.startPeriodicRefresh(poolAddress);
+            (0, dist_1.log_info)(`[TickCache] Pool ${poolAddress} initialized: ${ticks.size} ticks loaded`);
+        });
+    }
+    onSwap(poolAddress, newTick) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return;
+        state.currentTick = newTick;
+        const currentBitmapIndex = this.getBitmapIndex(newTick, state.tickSpacing);
+        if (!state.bitmapIndexes.includes(currentBitmapIndex)) {
+            (0, dist_1.log_info)(`[TickCache] Pool ${poolAddress}: tick ${newTick} out of cached range, scheduling refresh`);
+            this.scheduleFullRefresh(poolAddress);
+        }
+    }
+    onMint(poolAddress, tickLower, tickUpper, amount) {
+        this.applyLiquidityDelta(poolAddress, tickLower, tickUpper, amount);
+    }
+    onBurn(poolAddress, tickLower, tickUpper, amount) {
+        this.applyLiquidityDelta(poolAddress, tickLower, tickUpper, -amount);
+    }
+    onModifyLiquidity(poolAddress, tickLower, tickUpper, liquidityDelta) {
+        this.applyLiquidityDelta(poolAddress, tickLower, tickUpper, liquidityDelta);
+    }
+    applyLiquidityDelta(poolAddress, tickLower, tickUpper, delta) {
+        const state = this.pools.get(poolAddress);
+        if (!state) {
+            (0, dist_1.log_warn)(`[TickCache] Pool ${poolAddress} not initialized, ignoring liquidity event`);
+            return;
+        }
+        const absDelta = delta < BigInt(0) ? -delta : delta;
+        let needAsyncRefresh = false;
+        needAsyncRefresh = this.updateTickLiquidity(state, tickLower, delta, absDelta, true) || needAsyncRefresh;
+        needAsyncRefresh = this.updateTickLiquidity(state, tickUpper, -delta, absDelta, false) || needAsyncRefresh;
+        if (needAsyncRefresh) {
+            this.scheduleFullRefresh(poolAddress);
+        }
+        (0, dist_1.log_debug)(`[TickCache] Pool ${poolAddress}: liquidity delta applied, tickLower=${tickLower}, tickUpper=${tickUpper}, delta=${delta}`);
+    }
+    updateTickLiquidity(state, tickIndex, netDelta, grossDelta, isLower) {
+        const existing = state.ticks.get(tickIndex);
+        if (existing) {
+            existing.liquidityNet += netDelta;
+            existing.liquidityGross += (netDelta > BigInt(0) ? grossDelta : -grossDelta);
+            if (existing.liquidityGross <= BigInt(0)) {
+                state.ticks.delete(tickIndex);
+                (0, dist_1.log_debug)(`[TickCache] Tick ${tickIndex} de-initialized (liquidityGross <= 0)`);
+            }
+            return false;
+        }
+        if (netDelta > BigInt(0) || grossDelta > BigInt(0)) {
+            if (this.isInCachedRange(state, tickIndex)) {
+                state.ticks.set(tickIndex, {
+                    liquidityNet: netDelta,
+                    liquidityGross: grossDelta,
+                });
+                (0, dist_1.log_debug)(`[TickCache] New tick ${tickIndex} initialized in cached range`);
+                return false;
+            }
+            else {
+                (0, dist_1.log_debug)(`[TickCache] New tick ${tickIndex} outside cached range, will refresh async`);
+                return true;
+            }
+        }
+        return false;
+    }
+    getTickLiquidityNet(poolAddress, tickIndex) {
+        var _a;
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return undefined;
+        return (_a = state.ticks.get(tickIndex)) === null || _a === void 0 ? void 0 : _a.liquidityNet;
+    }
+    getTickInfo(poolAddress, tickIndex) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return undefined;
+        return state.ticks.get(tickIndex);
+    }
+    getCachedTickIndices(poolAddress) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return [];
+        return Array.from(state.ticks.keys()).sort((a, b) => a - b);
+    }
+    getTickSpacing(poolAddress) {
+        var _a;
+        return (_a = this.pools.get(poolAddress)) === null || _a === void 0 ? void 0 : _a.tickSpacing;
+    }
+    hasPool(poolAddress) {
+        return this.pools.has(poolAddress);
+    }
+    scheduleFullRefresh(poolAddress) {
+        const state = this.pools.get(poolAddress);
+        if (!state)
+            return;
+        const elapsed = Date.now() - state.lastFullLoadTime;
+        if (elapsed < this.config.minUpdateInterval) {
+            state.pendingForceRefresh = true;
+            return;
+        }
+        this.doFullRefresh(poolAddress).catch(err => {
+            (0, dist_1.log_warn)(`[TickCache] Full refresh failed for ${poolAddress}: ${err.message}`);
+        });
+    }
+    startPeriodicRefresh(poolAddress) {
+        const old = this.refreshTimers.get(poolAddress);
+        if (old)
+            clearInterval(old);
+        const timer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.doFullRefresh(poolAddress);
+            }
+            catch (err) {
+                (0, dist_1.log_warn)(`[TickCache] Periodic refresh failed for ${poolAddress}: ${err.message}`);
+            }
+        }), this.config.refreshInterval);
+        this.refreshTimers.set(poolAddress, timer);
+    }
+    doFullRefresh(poolAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = this.pools.get(poolAddress);
+            if (!state)
+                return;
+            if (state.loading) {
+                state.pendingForceRefresh = true;
+                return;
+            }
+            state.loading = true;
+            try {
+                const bitmapIndexes = this.calcBitmapIndexes(state.currentTick, state.tickSpacing);
+                const ticks = yield this.loader.loadBitmapWords(poolAddress, bitmapIndexes);
+                state.ticks = ticks;
+                state.bitmapIndexes = bitmapIndexes;
+                state.lastFullLoadTime = Date.now();
+                state.pendingForceRefresh = false;
+                (0, dist_1.log_debug)(`[TickCache] Full refresh for ${poolAddress}: ${ticks.size} ticks, ${bitmapIndexes.length} words`);
+            }
+            finally {
+                state.loading = false;
+                if (state.pendingForceRefresh) {
+                    state.pendingForceRefresh = false;
+                    this.doFullRefresh(poolAddress).catch(() => { });
+                }
+            }
+        });
+    }
+    getBitmapIndex(tick, tickSpacing) {
+        return Math.floor(tick / tickSpacing / 256);
+    }
+    calcBitmapIndexes(currentTick, tickSpacing) {
+        const center = this.getBitmapIndex(currentTick, tickSpacing);
+        const n = this.config.neighboringWords;
+        const indexes = [];
+        for (let i = -n; i <= n; i++) {
+            indexes.push(center + i);
+        }
+        return indexes;
+    }
+    isInCachedRange(state, tickIndex) {
+        const bitmapIndex = this.getBitmapIndex(tickIndex, state.tickSpacing);
+        return state.bitmapIndexes.includes(bitmapIndex);
+    }
+    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.ClmmTickCache = ClmmTickCache;

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

@@ -0,0 +1,2 @@
+export * from './clmm_tick_cache';
+export * from './tick_lens_loaders';

package/dist/{trade/send → quote/tick}/index.js

@@ -14,11 +14,5 @@ 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 });
-exports.BSC_EOA_ADDRESS = void 0;
-__exportStar(require("./send_tx"), exports);
-var BSC_EOA_ADDRESS;
-(function (BSC_EOA_ADDRESS) {
-    BSC_EOA_ADDRESS["BLOCKRAZOR"] = "0x1266C6bE60392A8Ff346E8d5ECCd3E69dD9c5F20";
-    BSC_EOA_ADDRESS["_48CLUB"] = "0x4848489f0b2BEdd788c696e2D79b6b69D7484848";
-    BSC_EOA_ADDRESS["BLXR"] = "0x74c5F8C6ffe41AD4789602BDB9a48E6Cad623520";
-})(BSC_EOA_ADDRESS || (exports.BSC_EOA_ADDRESS = BSC_EOA_ADDRESS = {}));
+__exportStar(require("./clmm_tick_cache"), exports);
+__exportStar(require("./tick_lens_loaders"), exports);

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

@@ -0,0 +1,25 @@
+import { TickInfo, TickLensLoader } from "./clmm_tick_cache";
+export declare const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+export declare const BSC_TICK_LENS_ADDRESSES: {
+    readonly PANCAKE_V3: "0x9a489505a00cE272eAa5e07Dba6491314CaE3796";
+    readonly UNISWAP_V3: "0xD9270014D396281579760619CCf4c3af0501A47C";
+    readonly PANCAKE_INFINITY_CL: "0x8BcF30285413F25032fb983C2bF4deFe29a33f3a";
+};
+export declare class MulticallTickLensLoader implements TickLensLoader {
+    private ethersLib;
+    private provider;
+    private tickLensAddress;
+    private tickLensAbi;
+    private multicallAddress;
+    private tickLensIface;
+    private multicallContract;
+    constructor(params: {
+        ethersLib: any;
+        provider: any;
+        tickLensAddress: string;
+        version: 'V3' | 'V4';
+        multicallAddress?: string;
+    });
+    loadBitmapWords(poolAddress: string, bitmapIndexes: number[]): Promise<Map<number, TickInfo>>;
+    private loadBitmapWordsIndividually;
+}

package/dist/quote/tick/tick_lens_loaders.js

@@ -0,0 +1,170 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulticallTickLensLoader = exports.BSC_TICK_LENS_ADDRESSES = exports.MULTICALL3_ADDRESS = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+exports.MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
+exports.BSC_TICK_LENS_ADDRESSES = {
+    PANCAKE_V3: '0x9a489505a00cE272eAa5e07Dba6491314CaE3796',
+    UNISWAP_V3: '0xD9270014D396281579760619CCf4c3af0501A47C',
+    PANCAKE_INFINITY_CL: '0x8BcF30285413F25032fb983C2bF4deFe29a33f3a',
+};
+const V3_TICK_LENS_ABI = [
+    {
+        type: 'function',
+        name: 'getPopulatedTicksInWord',
+        inputs: [
+            { name: 'pool', type: 'address' },
+            { name: 'tickBitmapIndex', type: 'int16' },
+        ],
+        outputs: [
+            {
+                name: 'populatedTicks',
+                type: 'tuple[]',
+                components: [
+                    { name: 'tick', type: 'int24' },
+                    { name: 'liquidityNet', type: 'int128' },
+                    { name: 'liquidityGross', type: 'uint128' },
+                ],
+            },
+        ],
+        stateMutability: 'view',
+    },
+];
+const V4_TICK_LENS_ABI = [
+    {
+        type: 'function',
+        name: 'getPopulatedTicksInWord',
+        inputs: [
+            { name: 'id', type: 'bytes32' },
+            { name: 'tickBitmapIndex', type: 'int16' },
+        ],
+        outputs: [
+            {
+                name: 'populatedTicks',
+                type: 'tuple[]',
+                components: [
+                    { name: 'tick', type: 'int24' },
+                    { name: 'liquidityNet', type: 'int128' },
+                    { name: 'liquidityGross', type: 'uint128' },
+                ],
+            },
+        ],
+        stateMutability: 'view',
+    },
+];
+const MULTICALL3_ABI = [
+    {
+        type: 'function',
+        name: 'aggregate',
+        inputs: [
+            {
+                name: 'calls',
+                type: 'tuple[]',
+                components: [
+                    { name: 'target', type: 'address' },
+                    { name: 'callData', type: 'bytes' },
+                ],
+            },
+        ],
+        outputs: [
+            { name: 'blockNumber', type: 'uint256' },
+            { name: 'returnData', type: 'bytes[]' },
+        ],
+        stateMutability: 'nonpayable',
+    },
+];
+class MulticallTickLensLoader {
+    constructor(params) {
+        this.ethersLib = params.ethersLib;
+        this.provider = params.provider;
+        this.tickLensAddress = params.tickLensAddress;
+        this.tickLensAbi = params.version === 'V4' ? V4_TICK_LENS_ABI : V3_TICK_LENS_ABI;
+        this.multicallAddress = params.multicallAddress || exports.MULTICALL3_ADDRESS;
+        this.tickLensIface = new params.ethersLib.Interface(this.tickLensAbi);
+        this.multicallContract = new params.ethersLib.Contract(this.multicallAddress, MULTICALL3_ABI, this.provider);
+    }
+    loadBitmapWords(poolAddress, bitmapIndexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const result = new Map();
+            if (bitmapIndexes.length === 0)
+                return result;
+            try {
+                const calls = bitmapIndexes.map(bitmapIndex => {
+                    const callData = this.tickLensIface.encodeFunctionData('getPopulatedTicksInWord', [
+                        poolAddress,
+                        bitmapIndex,
+                    ]);
+                    return {
+                        target: this.tickLensAddress,
+                        callData,
+                    };
+                });
+                const callMethod = this.multicallContract.aggregate.staticCall || ((_a = this.multicallContract.callStatic) === null || _a === void 0 ? void 0 : _a.aggregate);
+                const [, returnData] = yield callMethod(calls);
+                for (let i = 0; i < returnData.length; i++) {
+                    try {
+                        const decoded = this.tickLensIface.decodeFunctionResult('getPopulatedTicksInWord', returnData[i]);
+                        const populatedTicks = decoded[0];
+                        if (!populatedTicks || populatedTicks.length === 0)
+                            continue;
+                        for (const tick of populatedTicks) {
+                            const tickIndex = typeof tick.tick === 'bigint' ? Number(tick.tick) : tick.tick;
+                            result.set(tickIndex, {
+                                liquidityNet: typeof tick.liquidityNet === 'bigint'
+                                    ? tick.liquidityNet
+                                    : BigInt(String(tick.liquidityNet)),
+                                liquidityGross: typeof tick.liquidityGross === 'bigint'
+                                    ? tick.liquidityGross
+                                    : BigInt(String(tick.liquidityGross)),
+                            });
+                        }
+                    }
+                    catch (e) {
+                        (0, dist_1.log_warn)(`[TickLensLoader] Failed to decode bitmap index ${bitmapIndexes[i]}: ${e.message}`);
+                    }
+                }
+                (0, dist_1.log_debug)(`[TickLensLoader] Loaded ${result.size} ticks from ${bitmapIndexes.length} bitmap words (1 RPC call)`);
+            }
+            catch (error) {
+                (0, dist_1.log_warn)(`[TickLensLoader] Multicall failed, falling back to individual queries: ${error.message}`);
+                yield this.loadBitmapWordsIndividually(poolAddress, bitmapIndexes, result);
+            }
+            return result;
+        });
+    }
+    loadBitmapWordsIndividually(poolAddress, bitmapIndexes, result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tickLensContract = new this.ethersLib.Contract(this.tickLensAddress, this.tickLensAbi, this.provider);
+            const promises = bitmapIndexes.map((bitmapIndex) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                try {
+                    const callMethod = tickLensContract.getPopulatedTicksInWord.staticCall
+                        || ((_a = tickLensContract.callStatic) === null || _a === void 0 ? void 0 : _a.getPopulatedTicksInWord);
+                    const populatedTicks = yield callMethod(poolAddress, bitmapIndex);
+                    for (const tick of populatedTicks) {
+                        const tickIndex = Number(tick.tick);
+                        result.set(tickIndex, {
+                            liquidityNet: BigInt(tick.liquidityNet.toString()),
+                            liquidityGross: BigInt(tick.liquidityGross.toString()),
+                        });
+                    }
+                }
+                catch (e) {
+                    (0, dist_1.log_warn)(`[TickLensLoader] Bitmap index ${bitmapIndex} query failed for ${poolAddress}`);
+                }
+            }));
+            yield Promise.all(promises);
+        });
+    }
+}
+exports.MulticallTickLensLoader = MulticallTickLensLoader;

package/dist/redis/redis_client.d.ts

@@ -17,5 +17,6 @@ export declare class SimpleRedisClient {
     hgetvalue(key: string, field: string): Promise<any>;
     hkeys(key: string): Promise<any>;
     hgetall(key: string): Promise<any>;
+    lrange(key: string, start?: number, stop?: number): Promise<string[]>;
     del(key: string, field?: string): Promise<any>;
 }

package/dist/redis/redis_client.js

@@ -136,6 +136,12 @@ class SimpleRedisClient {
             return yield redisClient.hGetAll(key);
         });
     }
+    lrange(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, start = 0, stop = -1) {
+            const redisClient = yield this.getRedisClient();
+            return yield redisClient.lRange(key, start, stop);
+        });
+    }
     del(key_1) {
         return __awaiter(this, arguments, void 0, function* (key, field = '') {
             const redisClient = yield this.getRedisClient();

package/dist/trade/abstract_dex_trade.d.ts

@@ -1,27 +1,41 @@
 import { AbastrcatTrade, AppConfig, TradeContext } from "@clonegod/ttd-core/dist";
 import { ethers } from "ethers";
-import { DexConfig, EvmChainConfig } from "../types";
-export declare abstract class AbstractEvmDexTrade extends AbastrcatTrade {
+import { EvmChainConfig } from "../types";
+import { CallerManager } from "./caller_manager";
+import { TransactionSender } from "@clonegod/ttd-bsc-send-tx";
+import { SimpleRedisClient } from "../redis";
+export interface TradeConfig {
+    vaultAddress: string;
+    executorIds: Record<string, string>;
+}
+export declare function buildTradeConfig(): TradeConfig;
+export interface TradeCalldata {
+    executorId: string;
+    data: string;
+}
+export declare abstract class AbstractDexTrade extends AbastrcatTrade {
     protected appConfig: AppConfig;
-    protected wallet: ethers.Wallet;
+    protected callerManager: CallerManager;
     protected provider: ethers.providers.JsonRpcProvider;
-    protected approvedTokens: Map<string, boolean>;
-    protected pairContracts: Map<string, ethers.Contract>;
-    protected tokenContracts: Map<string, ethers.Contract>;
-    protected routerContract: ethers.Contract;
+    protected transactionSender: TransactionSender;
     protected chainConfig: EvmChainConfig;
-    protected dexConfig: DexConfig;
+    protected redisClient: SimpleRedisClient;
+    protected tradeConfig: TradeConfig;
+    protected vaultInterface: ethers.utils.Interface;
+    protected chainNameLower: string;
     constructor(appConfig: AppConfig);
     protected abstract initConfigs(): void;
+    abstract encodeTradeData(context: TradeContext): TradeCalldata;
     init(): Promise<void>;
-    protected getTokenContract(tokenAddress: string): ethers.Contract;
+    execute(context: TradeContext): Promise<string>;
+    private subscribeTradeMonitor;
     protected getGasPriceGwei(context: TradeContext): string;
     protected getBuilderTipAmoutGwei(context: TradeContext): string;
-    protected checkTradeTokenApprove(context: TradeContext, routerAddress?: string): Promise<void>;
-    protected checkTokenApprove(tokenAddress: string, tokenSymbol: string, tokenContract: ethers.Contract, spenderAddress: string): Promise<boolean>;
-    protected isNonceRelatedError(error: any): boolean;
-    protected isNativeCurrency(symbol: string): boolean;
-    protected getWrappedNativeAddress(): string;
-    abstract execute(context: TradeContext, retryCount?: number): Promise<string>;
-    protected buildTipTransferTx(to: string, transfer_amount_gwei: string, gas_price_gwei: string, transfer_nonce: number): Promise<string>;
+    protected buildTipTransferTx(to: string, transfer_amount_gwei: string, gas_price_gwei: string, nonce: number, wallet: ethers.Wallet): Promise<string>;
+    protected determineInputOutputTokens(order_msg: any, pool_info: any): {
+        inputToken: any;
+        outputToken: any;
+    };
+    protected calculateAmountOutMin(context: TradeContext, inputToken: any, outputToken: any): ethers.BigNumber;
+    private extractNonceFromErrorMsg;
 }