@clonegod/ttd-bsc-common 1.0.90 → 2.0.1

package/dist/config/BscQuoteAppConfig.d.ts

@@ -0,0 +1,11 @@
+import { BscEnvArgs } from "./bsc_env_args";
+import { AppConfig } from "@clonegod/ttd-core/dist";
+export declare class BscQuoteAppConfig extends AppConfig {
+    private eventEmitter;
+    env_args: BscEnvArgs;
+    constructor();
+    on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    emit(eventName: string | symbol, ...args: any[]): boolean;
+    init(): Promise<void>;
+    subscribe_config_change(): Promise<void>;
+}

package/dist/config/BscQuoteAppConfig.js

@@ -0,0 +1,62 @@
+"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.BscQuoteAppConfig = void 0;
+const bsc_env_args_1 = require("./bsc_env_args");
+const dist_1 = require("@clonegod/ttd-core/dist");
+const events_1 = require("events");
+class BscQuoteAppConfig extends dist_1.AppConfig {
+    constructor() {
+        super();
+        this.eventEmitter = new events_1.EventEmitter();
+        this.env_args = new bsc_env_args_1.BscEnvArgs();
+    }
+    on(eventName, listener) {
+        this.eventEmitter.on(eventName, listener);
+        return this;
+    }
+    emit(eventName, ...args) {
+        return this.eventEmitter.emit(eventName, ...args);
+    }
+    init() {
+        const _super = Object.create(null, {
+            init: { get: () => super.init }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.init.call(this);
+            yield this.arb_cache.init();
+            if (!this.arb_event_subscriber) {
+                this.arb_event_subscriber = (0, dist_1.getArbEventSubscriber)(this.arb_cache);
+            }
+            (0, dist_1.log_info)('BscQuoteAppConfig initialized', {
+                chain_id: this.env_args.chain_id,
+                dex_id: this.env_args.dex_id,
+                quote_pair: this.env_args.quote_pair,
+                rpc_endpoint: this.env_args.rpc_endpoint,
+                ws_endpoint: this.env_args.ws_endpoint,
+            });
+        });
+    }
+    subscribe_config_change() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.on('config_change', (config) => __awaiter(this, void 0, void 0, function* () {
+                (0, dist_1.log_info)('Config change received', config);
+                if (config.env_args) {
+                    this.env_args = new bsc_env_args_1.BscEnvArgs();
+                }
+                if (config.arb_cache) {
+                    yield this.arb_cache.init();
+                }
+            }));
+        });
+    }
+}
+exports.BscQuoteAppConfig = BscQuoteAppConfig;

package/dist/config/index.d.ts

@@ -1 +1,2 @@
 export * from './bsc_env_args';
+export * from './BscQuoteAppConfig';

package/dist/config/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./bsc_env_args"), exports);
+__exportStar(require("./BscQuoteAppConfig"), exports);

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

@@ -1 +1,2 @@
 export * from './pool_event_listener';
+export * from './swap_debouncer';

package/dist/quote/event/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./pool_event_listener"), exports);
+__exportStar(require("./swap_debouncer"), exports);

package/dist/quote/event/swap_debouncer.d.ts

@@ -0,0 +1,22 @@
+export declare class SwapDebouncer<TEvent extends {
+    pool_address: string;
+    type: string;
+    data: {
+        blockNumber: number;
+    };
+}, TResult = void> {
+    private debounceMs;
+    private onCalculate;
+    private onPublish;
+    private debouncedTypes;
+    private windows;
+    private latestBlock;
+    constructor(config: {
+        onCalculate: (event: TEvent) => TResult | Promise<TResult>;
+        onPublish: (event: TEvent, result: TResult) => void;
+        debouncedEventTypes?: string[];
+    });
+    onEvent(event: TEvent): Promise<void>;
+    flush(): void;
+    private startWindow;
+}

package/dist/quote/event/swap_debouncer.js

@@ -0,0 +1,92 @@
+"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.SwapDebouncer = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+class SwapDebouncer {
+    constructor(config) {
+        this.windows = new Map();
+        this.latestBlock = new Map();
+        this.debounceMs = parseInt(process.env.SWAP_DEBOUNCE_MS || '3', 10);
+        this.onCalculate = config.onCalculate;
+        this.onPublish = config.onPublish;
+        this.debouncedTypes = new Set((config.debouncedEventTypes || ['swap']).map(t => t.toLowerCase()));
+    }
+    onEvent(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const poolAddress = event.pool_address;
+            const blockNumber = ((_a = event.data) === null || _a === void 0 ? void 0 : _a.blockNumber) || 0;
+            if (blockNumber > 0) {
+                const lastBlock = this.latestBlock.get(poolAddress) || 0;
+                if (blockNumber < lastBlock) {
+                    (0, dist_1.log_warn)(`SwapDebouncer: stale block dropped, pool=${poolAddress}, event block=${blockNumber}, latest=${lastBlock}`);
+                    return;
+                }
+                this.latestBlock.set(poolAddress, blockNumber);
+            }
+            const eventType = (_b = event.type) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+            if (!this.debouncedTypes.has(eventType)) {
+                const result = yield this.onCalculate(event);
+                this.onPublish(event, result);
+                return;
+            }
+            const window = this.windows.get(poolAddress);
+            const result = yield this.onCalculate(event);
+            if (window) {
+                if (blockNumber > window.blockNumber) {
+                    if (!window.expired) {
+                        clearTimeout(window.timer);
+                        this.onPublish(window.latestEvent, window.latestResult);
+                    }
+                    this.windows.delete(poolAddress);
+                    this.startWindow(poolAddress, event, result, blockNumber);
+                }
+                else if (window.expired) {
+                    this.onPublish(event, result);
+                }
+                else {
+                    window.latestEvent = event;
+                    window.latestResult = result;
+                }
+            }
+            else {
+                this.startWindow(poolAddress, event, result, blockNumber);
+            }
+        });
+    }
+    flush() {
+        for (const [_, window] of this.windows) {
+            if (!window.expired) {
+                clearTimeout(window.timer);
+                this.onPublish(window.latestEvent, window.latestResult);
+            }
+        }
+        this.windows.clear();
+    }
+    startWindow(poolAddress, event, result, blockNumber) {
+        const timer = setTimeout(() => {
+            const w = this.windows.get(poolAddress);
+            if (w) {
+                w.expired = true;
+                this.onPublish(w.latestEvent, w.latestResult);
+            }
+        }, this.debounceMs);
+        this.windows.set(poolAddress, {
+            blockNumber,
+            latestEvent: event,
+            latestResult: result,
+            timer,
+            expired: false,
+        });
+    }
+}
+exports.SwapDebouncer = SwapDebouncer;

package/dist/quote/index.d.ts

@@ -1,2 +1,3 @@
 export * from './event';
 export * from './pricing';
+export * from './tick';

package/dist/quote/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./event"), exports);
 __exportStar(require("./pricing"), exports);
+__exportStar(require("./tick"), exports);

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

@@ -1,2 +1,4 @@
 export * from './token_price_cache';
 export * from './pool';
+export * from './sdk_token_factory';
+export * from './pool_state_initializer';

package/dist/quote/pricing/index.js

@@ -16,3 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./token_price_cache"), exports);
 __exportStar(require("./pool"), exports);
+__exportStar(require("./sdk_token_factory"), exports);
+__exportStar(require("./pool_state_initializer"), exports);

package/dist/quote/pricing/pool_state_initializer.d.ts

@@ -0,0 +1,8 @@
+import { AmmPoolState, ClmmPoolState, InfinityPoolState } from "../../types/pool_state";
+export declare class PoolStateInitializer {
+    static initAmmPool(provider: any, poolAddress: string, dexId: string, ethersLib: any): Promise<AmmPoolState>;
+    static initClmmPool(provider: any, poolAddress: string, ethersLib: any, poolAbi?: any[]): Promise<ClmmPoolState>;
+    static initInfinityPool(provider: any, poolKey: string, poolManagerAddress: string, poolManagerAbi: any, ethersLib: any, decodeParameters: (params: string) => {
+        tickSpacing: number;
+    }): Promise<InfinityPoolState>;
+}

package/dist/quote/pricing/pool_state_initializer.js

@@ -0,0 +1,142 @@
+"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.PoolStateInitializer = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const V2_PAIR_ABI = [
+    'function token0() view returns (address)',
+    'function token1() view returns (address)',
+    'function getReserves() view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)',
+];
+const V3_POOL_ABI = [
+    'function token0() view returns (address)',
+    'function token1() view returns (address)',
+    'function fee() view returns (uint24)',
+    'function tickSpacing() view returns (int24)',
+    'function slot0() view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)',
+    'function liquidity() view returns (uint128)',
+];
+const AMM_FEE_MAP = {
+    'PANCAKE-AMM': 25,
+    'PANCAKE_AMM': 25,
+    'UNISWAP-AMM': 30,
+    'UNISWAP_AMM': 30,
+};
+class PoolStateInitializer {
+    static initAmmPool(provider, poolAddress, dexId, ethersLib) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const poolContract = new ethersLib.Contract(poolAddress, V2_PAIR_ABI, provider);
+                const [reserves, token0, token1] = yield Promise.all([
+                    poolContract.getReserves(),
+                    poolContract.token0(),
+                    poolContract.token1(),
+                ]);
+                const fee = AMM_FEE_MAP[dexId] || AMM_FEE_MAP[dexId.replace('-', '_')] || 30;
+                const state = {
+                    address: poolAddress,
+                    token0: token0.toLowerCase(),
+                    token1: token1.toLowerCase(),
+                    fee,
+                    reserve0: reserves[0].toString(),
+                    reserve1: reserves[1].toString(),
+                };
+                (0, dist_1.log_info)(`[PoolStateInitializer] AMM pool initialized: ${poolAddress}`, {
+                    token0: state.token0, token1: state.token1, fee: state.fee,
+                });
+                return state;
+            }
+            catch (error) {
+                (0, dist_1.log_error)(`[PoolStateInitializer] Failed to init AMM pool ${poolAddress}:`, error);
+                throw error;
+            }
+        });
+    }
+    static initClmmPool(provider, poolAddress, ethersLib, poolAbi) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const abi = poolAbi || V3_POOL_ABI;
+                const poolContract = new ethersLib.Contract(poolAddress, abi, provider);
+                const [token0, token1, fee, tickSpacing, slot0, liquidity] = yield Promise.all([
+                    poolContract.token0(),
+                    poolContract.token1(),
+                    poolContract.fee(),
+                    poolContract.tickSpacing(),
+                    poolContract.slot0(),
+                    poolContract.liquidity(),
+                ]);
+                const [sqrtPriceX96, tick] = slot0;
+                const state = {
+                    address: poolAddress,
+                    token0: token0.toLowerCase(),
+                    token1: token1.toLowerCase(),
+                    fee: Number(fee),
+                    tickSpacing: Number(tickSpacing),
+                    tick: Number(tick),
+                    sqrtPriceX96: sqrtPriceX96.toString(),
+                    liquidity: liquidity.toString(),
+                };
+                (0, dist_1.log_info)(`[PoolStateInitializer] CLMM pool initialized: ${poolAddress}`, {
+                    token0: state.token0, token1: state.token1,
+                    fee: state.fee, tickSpacing: state.tickSpacing, tick: state.tick,
+                });
+                return state;
+            }
+            catch (error) {
+                (0, dist_1.log_error)(`[PoolStateInitializer] Failed to init CLMM pool ${poolAddress}:`, error);
+                throw error;
+            }
+        });
+    }
+    static initInfinityPool(provider, poolKey, poolManagerAddress, poolManagerAbi, ethersLib, decodeParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const poolManagerContract = new ethersLib.Contract(poolManagerAddress, poolManagerAbi, provider);
+                const [slot0Result, liquidity, poolKeyInfo] = yield Promise.all([
+                    poolManagerContract.getSlot0(poolKey),
+                    poolManagerContract.getLiquidity(poolKey),
+                    poolManagerContract.poolIdToPoolKey(poolKey),
+                ]);
+                const [sqrtPriceX96, tick, protocolFee, lpFee] = slot0Result;
+                const [currency0, currency1, hooks, poolManager, fee, parameters] = poolKeyInfo;
+                const { tickSpacing } = decodeParameters(parameters);
+                const state = {
+                    address: poolKey,
+                    token0: currency0.toLowerCase ? currency0.toLowerCase() : currency0,
+                    token1: currency1.toLowerCase ? currency1.toLowerCase() : currency1,
+                    fee: Number(fee),
+                    tickSpacing,
+                    tick: Number(tick),
+                    sqrtPriceX96: sqrtPriceX96.toString(),
+                    liquidity: liquidity.toString(),
+                    hooks,
+                    poolManager,
+                    parameters,
+                    currency0,
+                    currency1,
+                    lpFee: Number(lpFee),
+                    protocolFee: Number(protocolFee),
+                };
+                (0, dist_1.log_info)(`[PoolStateInitializer] Infinity pool initialized: ${poolKey}`, {
+                    currency0: state.currency0, currency1: state.currency1,
+                    fee: state.fee, tickSpacing: state.tickSpacing, tick: state.tick,
+                    lpFee: state.lpFee, protocolFee: state.protocolFee,
+                });
+                return state;
+            }
+            catch (error) {
+                (0, dist_1.log_error)(`[PoolStateInitializer] Failed to init Infinity pool ${poolKey}:`, error);
+                throw error;
+            }
+        });
+    }
+}
+exports.PoolStateInitializer = PoolStateInitializer;

package/dist/quote/pricing/sdk_token_factory.d.ts

@@ -0,0 +1,2 @@
+import { StandardPoolInfoType } from "@clonegod/ttd-core";
+export declare function buildSdkTokenMap<T>(chainId: number, poolInfoMap: Map<string, StandardPoolInfoType>, TokenClass: new (chainId: number, address: string, decimals: number, symbol?: string, name?: string) => T): Map<string, T>;

package/dist/quote/pricing/sdk_token_factory.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSdkTokenMap = buildSdkTokenMap;
+const dist_1 = require("@clonegod/ttd-core/dist");
+function buildSdkTokenMap(chainId, poolInfoMap, TokenClass) {
+    const sdkTokens = new Map();
+    for (const poolInfo of poolInfoMap.values()) {
+        const tokens = [poolInfo.tokenA, poolInfo.tokenB];
+        for (const tokenInfo of tokens) {
+            const address = tokenInfo.address;
+            if (sdkTokens.has(address))
+                continue;
+            let symbol = tokenInfo.symbol || address.substring(0, 6);
+            let name = tokenInfo.name || `Token ${address.substring(0, 8)}`;
+            const token = new TokenClass(chainId, address, tokenInfo.decimals, symbol, name);
+            sdkTokens.set(address, token);
+            (0, dist_1.log_debug)(`Created SDK Token: ${address}, symbol: ${symbol}, decimals: ${tokenInfo.decimals}`, '');
+        }
+    }
+    return sdkTokens;
+}

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

@@ -0,0 +1,40 @@
+export interface TickInfo {
+    liquidityNet: bigint;
+    liquidityGross: bigint;
+}
+export interface ClmmTickCacheConfig {
+    neighboringWords?: number;
+    refreshInterval?: number;
+    minUpdateInterval?: number;
+}
+export interface TickLensLoader {
+    loadBitmapWords(poolAddress: string, bitmapIndexes: number[]): Promise<Map<number, TickInfo>>;
+}
+export declare class ClmmTickCache {
+    private pools;
+    private refreshTimers;
+    private loadPromises;
+    private loader;
+    private config;
+    constructor(loader: TickLensLoader, config?: ClmmTickCacheConfig);
+    initPool(poolAddress: string, currentTick: number, tickSpacing: number): Promise<void>;
+    onSwap(poolAddress: string, newTick: number): void;
+    onMint(poolAddress: string, tickLower: number, tickUpper: number, amount: bigint): void;
+    onBurn(poolAddress: string, tickLower: number, tickUpper: number, amount: bigint): void;
+    onModifyLiquidity(poolAddress: string, tickLower: number, tickUpper: number, liquidityDelta: bigint): void;
+    private applyLiquidityDelta;
+    private updateTickLiquidity;
+    getTickLiquidityNet(poolAddress: string, tickIndex: number): bigint | undefined;
+    getTickInfo(poolAddress: string, tickIndex: number): TickInfo | undefined;
+    getCachedTickIndices(poolAddress: string): number[];
+    getTickSpacing(poolAddress: string): number | undefined;
+    hasPool(poolAddress: string): boolean;
+    private scheduleFullRefresh;
+    private startPeriodicRefresh;
+    private doFullRefresh;
+    private getBitmapIndex;
+    private calcBitmapIndexes;
+    private isInCachedRange;
+    clearPool(poolAddress: string): void;
+    destroy(): void;
+}