@clonegod/ttd-bsc-common 1.0.90 → 3.0.1

package/dist/config/BscQuoteAppConfig.d.ts

@@ -0,0 +1,11 @@
+import { BscEnvArgs } from "./bsc_env_args";
+import { AppConfig } from '@clonegod/ttd-core';
+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 ttd_core_1 = require("@clonegod/ttd-core");
+const events_1 = require("events");
+class BscQuoteAppConfig extends ttd_core_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, ttd_core_1.getArbEventSubscriber)(this.arb_cache);
+            }
+            (0, ttd_core_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, ttd_core_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/bsc_env_args.d.ts

@@ -1,4 +1,4 @@
-import { EnvArgs } from "@clonegod/ttd-core/dist";
+import { EnvArgs } from '@clonegod/ttd-core';
 export declare class BscEnvArgs extends EnvArgs {
     large_trade_threshold_usd: number;
     gas_price_gwei: number;

package/dist/config/bsc_env_args.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BscEnvArgs = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 const decimal_js_1 = require("decimal.js");
-class BscEnvArgs extends dist_1.EnvArgs {
+class BscEnvArgs extends ttd_core_1.EnvArgs {
     constructor() {
         super();
         this.large_trade_threshold_usd = parseInt(process.env.LARGE_TRADE_THRESHOLD_USD || '500');

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/pool_event_listener.d.ts

@@ -1,5 +1,5 @@
 import { StandardPoolInfoType } from '@clonegod/ttd-core';
-import { AppConfig } from '@clonegod/ttd-core/dist';
+import { AppConfig } from '@clonegod/ttd-core';
 export interface BlockUpdateEvent {
     blockNumber: number;
     previousBlockNumber: number;

package/dist/quote/event/pool_event_listener.js

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PoolEventListener = void 0;
 const ethers_1 = require("ethers");
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ttd_core_1 = require("@clonegod/ttd-core");
 const common_1 = require("../../common");
 const CONFIG = {
     MAX_RETRIES: 3,
@@ -48,37 +48,37 @@ class PoolEventListener {
         return __awaiter(this, void 0, void 0, function* () {
             this.poolList = poolList.filter(pool => ethers_1.ethers.utils.isAddress(pool.pool_address));
             if (this.poolList.length !== poolList.length) {
-                (0, dist_1.log_warn)(`Found ${poolList.length - this.poolList.length} invalid pool addresses, filtered out`, '');
+                (0, ttd_core_1.log_warn)(`Found ${poolList.length - this.poolList.length} invalid pool addresses, filtered out`, '');
             }
             yield this.connect();
         });
     }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
-            (0, dist_1.log_info)(`Starting block listener...`);
+            (0, ttd_core_1.log_info)(`Starting block listener...`);
             if (!this.isConnected || !this.wsProvider) {
-                (0, dist_1.log_warn)('WebSocket not connected, cannot start listener', '');
+                (0, ttd_core_1.log_warn)('WebSocket not connected, cannot start listener', '');
                 return;
             }
             yield this.startBlockListener();
             this.isStarted = true;
-            (0, dist_1.log_info)('Block listener started successfully');
+            (0, ttd_core_1.log_info)('Block listener started successfully');
         });
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
-            (0, dist_1.log_info)(`Stopping block listener...`);
+            (0, ttd_core_1.log_info)(`Stopping block listener...`);
             this.stopBlockListener();
             this.cleanup();
             this.isStarted = false;
-            (0, dist_1.log_info)(`Block listener stopped`);
+            (0, ttd_core_1.log_info)(`Block listener stopped`);
         });
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
             for (let i = 0; i < CONFIG.MAX_RETRIES; i++) {
                 try {
-                    (0, dist_1.log_info)(`Connecting to WebSocket: ${this.ws_endpoint} (Attempt ${i + 1}/${CONFIG.MAX_RETRIES})`);
+                    (0, ttd_core_1.log_info)(`Connecting to WebSocket: ${this.ws_endpoint} (Attempt ${i + 1}/${CONFIG.MAX_RETRIES})`);
                     this.wsProvider = new ethers_1.ethers.providers.WebSocketProvider(this.ws_endpoint);
                     const wsPromise = this.wsProvider.ready;
                     const timeoutPromise = new Promise((_, reject) => {
@@ -87,7 +87,7 @@ class PoolEventListener {
                     yield Promise.race([wsPromise, timeoutPromise]);
                     this.isConnected = true;
                     this.reconnectAttempts = 0;
-                    (0, dist_1.log_info)(`WebSocket connected: ${this.ws_endpoint}`);
+                    (0, ttd_core_1.log_info)(`WebSocket connected: ${this.ws_endpoint}`);
                     this.setupWebSocketListeners();
                     if (this.isStarted) {
                         yield this.startBlockListener();
@@ -95,12 +95,12 @@ class PoolEventListener {
                     return;
                 }
                 catch (error) {
-                    (0, dist_1.log_error)(`WebSocket connection failed (Attempt ${i + 1}/${CONFIG.MAX_RETRIES}):`, error);
+                    (0, ttd_core_1.log_error)(`WebSocket connection failed (Attempt ${i + 1}/${CONFIG.MAX_RETRIES}):`, error);
                     if (i === CONFIG.MAX_RETRIES - 1) {
                         throw error;
                     }
                     const delay = CONFIG.RETRY_DELAY_MULTIPLIER * (i + 1);
-                    (0, dist_1.log_info)(`Waiting ${delay / 1000} seconds before retry...`);
+                    (0, ttd_core_1.log_info)(`Waiting ${delay / 1000} seconds before retry...`);
                     yield new Promise(resolve => setTimeout(resolve, delay));
                 }
             }
@@ -110,15 +110,15 @@ class PoolEventListener {
         if (!this.wsProvider)
             return;
         this.wsProvider.on('error', (err) => {
-            (0, dist_1.log_error)(`WebSocket error:`, err, '');
+            (0, ttd_core_1.log_error)(`WebSocket error:`, err, '');
             this.handleConnectionIssue();
         });
         this.wsProvider._websocket.on('close', (code, reason) => {
-            (0, dist_1.log_warn)(`WebSocket connection closed, code: ${code}, reason: ${reason || 'unknown'}`);
+            (0, ttd_core_1.log_warn)(`WebSocket connection closed, code: ${code}, reason: ${reason || 'unknown'}`);
             this.handleConnectionIssue();
         });
         this.wsProvider._websocket.on('open', () => {
-            (0, dist_1.log_info)('WebSocket connection opened');
+            (0, ttd_core_1.log_info)('WebSocket connection opened');
             this.isConnected = true;
             this.reconnectAttempts = 0;
         });
@@ -138,12 +138,12 @@ class PoolEventListener {
                 this.lastHeartbeatResponse = Date.now();
                 const timeSinceLastHeartbeat = Date.now() - this.lastHeartbeatResponse;
                 if (timeSinceLastHeartbeat > CONFIG.HEARTBEAT_TIMEOUT) {
-                    (0, dist_1.log_warn)(`No heartbeat response for ${timeSinceLastHeartbeat / 1000} seconds`);
+                    (0, ttd_core_1.log_warn)(`No heartbeat response for ${timeSinceLastHeartbeat / 1000} seconds`);
                     this.handleConnectionIssue();
                 }
             }
             catch (error) {
-                (0, dist_1.log_error)('Heartbeat check failed:', error);
+                (0, ttd_core_1.log_error)('Heartbeat check failed:', error);
                 this.handleConnectionIssue();
             }
         }), CONFIG.HEARTBEAT_INTERVAL);
@@ -151,7 +151,7 @@ class PoolEventListener {
     handleConnectionIssue() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isReconnecting) {
-                (0, dist_1.log_info)('Already attempting to reconnect, skipping...');
+                (0, ttd_core_1.log_info)('Already attempting to reconnect, skipping...');
                 return;
             }
             this.isReconnecting = true;
@@ -161,20 +161,20 @@ class PoolEventListener {
                 this.cleanup();
                 this.reconnectAttempts++;
                 const delay = Math.min(CONFIG.BASE_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts), CONFIG.MAX_RECONNECT_DELAY);
-                (0, dist_1.log_info)(`Attempting to reconnect ${this.reconnectAttempts}/${CONFIG.MAX_RECONNECT_ATTEMPTS}, delay ${delay}ms, node: ${this.ws_endpoint}`);
+                (0, ttd_core_1.log_info)(`Attempting to reconnect ${this.reconnectAttempts}/${CONFIG.MAX_RECONNECT_ATTEMPTS}, delay ${delay}ms, node: ${this.ws_endpoint}`);
                 if (this.reconnectAttempts > CONFIG.MAX_RECONNECT_ATTEMPTS) {
-                    (0, dist_1.log_error)(`Reconnection failed, reached maximum attempts (${CONFIG.MAX_RECONNECT_ATTEMPTS}), exiting`, new Error('Max reconnect attempts failed'), '');
+                    (0, ttd_core_1.log_error)(`Reconnection failed, reached maximum attempts (${CONFIG.MAX_RECONNECT_ATTEMPTS}), exiting`, new Error('Max reconnect attempts failed'), '');
                     this.appConfig.emit(common_1.EVENT_NAMES.WS_CONNECTION_FAILED, {
                         endpoint: this.ws_endpoint,
                         attempts: CONFIG.MAX_RECONNECT_ATTEMPTS,
                     });
                     process.exit(1);
                 }
-                yield (0, dist_1.sleep)(delay);
+                yield (0, ttd_core_1.sleep)(delay);
                 yield this.connect();
             }
             catch (error) {
-                (0, dist_1.log_error)('Reconnection attempt failed:', error);
+                (0, ttd_core_1.log_error)('Reconnection attempt failed:', error);
                 setTimeout(() => this.handleConnectionIssue(), CONFIG.BASE_RECONNECT_DELAY);
             }
             finally {
@@ -185,19 +185,19 @@ class PoolEventListener {
     startBlockListener() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.wsProvider || !this.isConnected) {
-                (0, dist_1.log_warn)(`Cannot start block listener: WebSocket not connected`);
+                (0, ttd_core_1.log_warn)(`Cannot start block listener: WebSocket not connected`);
                 return;
             }
             try {
                 const blockNumber = yield this.wsProvider.getBlockNumber();
                 this.lastProcessedBlockNumber = blockNumber;
-                (0, dist_1.log_info)(`Initializing block listener, current block: ${blockNumber}`);
+                (0, ttd_core_1.log_info)(`Initializing block listener, current block: ${blockNumber}`);
                 this.wsProvider.on('block', (blockNumber) => __awaiter(this, void 0, void 0, function* () {
                     try {
                         if (!this.isConnected || !this.isBlockListenerActive)
                             return;
                         this.lastMessageTime = Date.now();
-                        (0, dist_1.log_info)(`------- Block: ${blockNumber} -------`);
+                        (0, ttd_core_1.log_info)(`------- Block: ${blockNumber} -------`);
                         const previousBlockNumber = this.lastProcessedBlockNumber;
                         this.lastProcessedBlockNumber = blockNumber;
                         const blockUpdateEvent = {
@@ -208,16 +208,16 @@ class PoolEventListener {
                         this.appConfig.emit(common_1.EVENT_NAMES.BLOCK_UPDATE, blockUpdateEvent);
                     }
                     catch (error) {
-                        (0, dist_1.log_error)(`Error processing block event:`, error, '');
+                        (0, ttd_core_1.log_error)(`Error processing block event:`, error, '');
                     }
                 }));
                 this.startMessageMonitor();
                 this.startDiagnosticMonitor();
                 this.isBlockListenerActive = true;
-                (0, dist_1.log_info)(`Block listener started using WebSocket event subscription`);
+                (0, ttd_core_1.log_info)(`Block listener started using WebSocket event subscription`);
             }
             catch (error) {
-                (0, dist_1.log_error)(`Failed to start block listener:`, error, '');
+                (0, ttd_core_1.log_error)(`Failed to start block listener:`, error, '');
                 this.isBlockListenerActive = false;
             }
         });
@@ -229,7 +229,7 @@ class PoolEventListener {
         this.messageMonitorInterval = setInterval(() => {
             const timeSinceLastMessage = Date.now() - this.lastMessageTime;
             if (timeSinceLastMessage > CONFIG.MESSAGE_TIMEOUT) {
-                (0, dist_1.log_warn)(`No messages received for ${CONFIG.MESSAGE_TIMEOUT / 1000} seconds, preparing to resubscribe`);
+                (0, ttd_core_1.log_warn)(`No messages received for ${CONFIG.MESSAGE_TIMEOUT / 1000} seconds, preparing to resubscribe`);
                 this.handleConnectionIssue();
             }
         }, CONFIG.MESSAGE_CHECK_INTERVAL);
@@ -244,7 +244,7 @@ class PoolEventListener {
         }, CONFIG.DIAGNOSTIC_INTERVAL);
     }
     logDiagnostics(diagnostics) {
-        (0, dist_1.log_info)(`WebSocket Connection Diagnostics:
+        (0, ttd_core_1.log_info)(`WebSocket Connection Diagnostics:
             Connection Status: ${diagnostics.isConnected ? 'Connected' : 'Disconnected'}
             Reconnection Status: ${diagnostics.isReconnecting ? 'Reconnecting' : 'Not Reconnecting'}
             Listener Status: ${diagnostics.isStarted ? 'Started' : 'Not Started'}
@@ -279,7 +279,7 @@ class PoolEventListener {
                 clearInterval(this.diagnosticInterval);
                 this.diagnosticInterval = null;
             }
-            (0, dist_1.log_info)(`Block listener stopped`);
+            (0, ttd_core_1.log_info)(`Block listener stopped`);
         }
     }
     cleanup() {
@@ -291,7 +291,7 @@ class PoolEventListener {
                 }
             }
             catch (error) {
-                (0, dist_1.log_error)(`Failed to cleanup WebSocket resources:`, error, '');
+                (0, ttd_core_1.log_error)(`Failed to cleanup WebSocket resources:`, error, '');
             }
             this.wsProvider = null;
         }

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 ttd_core_1 = require("@clonegod/ttd-core");
+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, ttd_core_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 ttd_core_1 = require("@clonegod/ttd-core");
+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, ttd_core_1.log_info)(`[PoolStateInitializer] AMM pool initialized: ${poolAddress}`, {
+                    token0: state.token0, token1: state.token1, fee: state.fee,
+                });
+                return state;
+            }
+            catch (error) {
+                (0, ttd_core_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, ttd_core_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, ttd_core_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, ttd_core_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, ttd_core_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>;