@clonegod/ttd-base-common 1.0.0

package/dist/trade/abstract_dex_trade.js

@@ -0,0 +1,153 @@
+"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.AbstractEvmDexTrade = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const ethers_1 = require("ethers");
+const common_1 = require("../common");
+class AbstractEvmDexTrade extends dist_1.AbastrcatTrade {
+    constructor(appConfig) {
+        super();
+        this.appConfig = appConfig;
+        this.approvedTokens = new Map();
+        this.pairContracts = new Map();
+        this.tokenContracts = new Map();
+        this.approvedTokens = new Map();
+        this.pairContracts = new Map();
+        this.tokenContracts = new Map();
+        this.initConfigs();
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.provider = new ethers_1.ethers.providers.JsonRpcProvider(this.chainConfig.rpcEndpoint);
+            this.wallet = new ethers_1.ethers.Wallet(this.appConfig.trade_runtime.wallet.private_key, this.provider);
+            (0, dist_1.log_info)(`钱包已初始化，地址: ${this.wallet.address}`);
+            this.routerContract = new ethers_1.ethers.Contract(this.dexConfig.routerAddress, this.dexConfig.routerAbi, this.wallet);
+            (0, dist_1.log_info)(`${this.dexConfig.dexName} Router已初始化, 地址: ${this.dexConfig.routerAddress}`);
+        });
+    }
+    getTokenContract(tokenAddress) {
+        if (!this.tokenContracts.has(tokenAddress)) {
+            const tokenContract = new ethers_1.ethers.Contract(tokenAddress, common_1.ERC20_ABI, this.wallet);
+            this.tokenContracts.set(tokenAddress, tokenContract);
+        }
+        return this.tokenContracts.get(tokenAddress);
+    }
+    getGasPriceGwei(context) {
+        let { evm_gas_limit, evm_gas_price_gwei, evm_tip_amount_gwei } = context.trade_runtime.settings.strategy;
+        if (evm_gas_price_gwei === undefined || evm_gas_price_gwei === null || evm_gas_price_gwei <= 0) {
+            evm_gas_price_gwei = this.chainConfig.gasOptions.defaultGasPriceGwei;
+        }
+        (0, dist_1.log_info)(`getGasPriceGwei: ${evm_gas_price_gwei} Gwei`);
+        return evm_gas_price_gwei.toString();
+    }
+    getBuilderTipAmoutGwei(context) {
+        let { evm_gas_limit, evm_gas_price_gwei, evm_tip_amount_gwei } = context.trade_runtime.settings.strategy;
+        if (evm_tip_amount_gwei === undefined || evm_tip_amount_gwei === null || evm_tip_amount_gwei <= 0) {
+            evm_tip_amount_gwei = this.chainConfig.gasOptions.defaultTipAmountGwei;
+        }
+        (0, dist_1.log_info)(`getGasTipAmoutGwei: ${evm_tip_amount_gwei} Gwei`);
+        return evm_tip_amount_gwei.toString();
+    }
+    checkTradeTokenApprove(context, routerAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { pool_info } = context;
+            const { tokenA, tokenB } = pool_info;
+            const router = routerAddress || this.dexConfig.routerAddress;
+            yield Promise.all([tokenA, tokenB].map((_a) => __awaiter(this, [_a], void 0, function* ({ symbol, address }) {
+                const tokenContract = this.getTokenContract(address);
+                yield this.checkTokenApprove(address, symbol, tokenContract, router);
+            })));
+        });
+    }
+    checkTokenApprove(tokenAddress, tokenSymbol, tokenContract, spenderAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.approvedTokens.get(tokenAddress)) {
+                (0, dist_1.log_info)(`代币 ${tokenSymbol} 已授权，跳过授权检查`);
+                return true;
+            }
+            const allowance = yield tokenContract.allowance(this.wallet.address, spenderAddress);
+            const maxAllowance = ethers_1.ethers.constants.MaxUint256.div(2);
+            (0, dist_1.log_info)(`代币授权检查:`, {
+                tokenSymbol,
+                currentAllowance: allowance.toString(),
+                maxAllowance: maxAllowance.toString(),
+                isSufficient: allowance.gte(maxAllowance)
+            });
+            if (allowance.lt(maxAllowance)) {
+                const maxApprovalAmount = ethers_1.ethers.utils.formatUnits(ethers_1.ethers.constants.MaxUint256, yield tokenContract.decimals());
+                const tokenSymbolDisplay = tokenSymbol || `${tokenAddress.substring(0, 6)}...`;
+                (0, dist_1.log_info)(`正在为合约授权代币 ${tokenSymbolDisplay}`, {
+                    tokenAddress,
+                    tokenSymbol: tokenSymbolDisplay,
+                    currentAllowance: ethers_1.ethers.utils.formatUnits(allowance, yield tokenContract.decimals()),
+                    newAllowance: maxApprovalAmount
+                });
+                const tx = yield tokenContract.approve(spenderAddress, ethers_1.ethers.constants.MaxUint256, {
+                    gasLimit: this.chainConfig.gasOptions.gasLimit
+                });
+                yield tx.wait();
+                this.approvedTokens.set(tokenAddress, true);
+                (0, dist_1.log_info)(`代币 ${tokenSymbolDisplay} 授权完成，数量: ${maxApprovalAmount} ${tokenSymbolDisplay}, 交易哈希: ${tx.hash}`);
+                return true;
+            }
+            else {
+                this.approvedTokens.set(tokenAddress, true);
+                return true;
+            }
+        });
+    }
+    isNonceRelatedError(error) {
+        if (!error)
+            return false;
+        const errorMessage = error.message ? error.message.toLowerCase() : '';
+        const nonceErrorKeywords = [
+            'nonce',
+            'nonce too low',
+            'nonce too high',
+            'nonce has already been used',
+            'already known',
+            'replacement transaction underpriced',
+            'transaction with same nonce',
+            'transaction nonce is too low',
+            'invalid transaction nonce',
+            'insufficient funds',
+            'sign bundle to get failure details',
+        ];
+        return nonceErrorKeywords.some(keyword => errorMessage.includes(keyword));
+    }
+    isNativeCurrency(symbol) {
+        return symbol.toUpperCase() === this.chainConfig.nativeCurrency;
+    }
+    getWrappedNativeAddress() {
+        return this.chainConfig.wrappedNativeCurrencyAddress;
+    }
+    buildTipTransferTx(to, transfer_amount_gwei, gas_price_gwei, transfer_nonce) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let real_transfer_amount_gwei = Math.min(Number(transfer_amount_gwei), this.chainConfig.gasOptions.maxTipAmountGwei).toString();
+            let real_gas_price_gwei = Math.min(Number(gas_price_gwei), this.chainConfig.gasOptions.maxGasPriceGwei).toString();
+            let tx_data = {
+                from: this.wallet.address,
+                to,
+                value: ethers_1.ethers.utils.parseUnits(real_transfer_amount_gwei, 'gwei'),
+                gasLimit: 21000,
+                gasPrice: ethers_1.ethers.utils.parseUnits(real_gas_price_gwei, 'gwei'),
+                nonce: transfer_nonce,
+                chainId: this.chainConfig.chainId
+            };
+            let signedTx = yield this.wallet.signTransaction(tx_data);
+            (0, dist_1.log_info)(`构建转账交易: `, Object.assign(Object.assign({}, tx_data), { real_transfer_amount_gwei,
+                real_gas_price_gwei, txhash: ethers_1.ethers.utils.keccak256(signedTx) }));
+            return signedTx;
+        });
+    }
+}
+exports.AbstractEvmDexTrade = AbstractEvmDexTrade;

package/dist/trade/abstract_dex_trade_plus.d.ts

@@ -0,0 +1,30 @@
+import { AbastrcatTrade, AppConfig, TradeContext } from "@clonegod/ttd-core/dist";
+import { ethers } from "ethers";
+import { DexConfig, EvmChainConfig } from "../types";
+export declare abstract class AbstractEvmDexTradePlus extends AbastrcatTrade {
+    protected appConfig: AppConfig;
+    protected group_wallets: ethers.Wallet[];
+    protected provider: ethers.providers.JsonRpcProvider;
+    protected approvedTokens: Map<string, Map<string, boolean>>;
+    protected pairContracts: Map<string, ethers.Contract>;
+    protected tokenContracts: Map<string, ethers.Contract>;
+    protected routerContract: ethers.Contract;
+    protected chainConfig: EvmChainConfig;
+    protected dexConfig: DexConfig;
+    constructor(appConfig: AppConfig);
+    protected abstract initConfigs(): void;
+    init(): Promise<void>;
+    protected getTokenContract(tokenAddress: string): ethers.Contract;
+    protected getTokenContractWithWallet(tokenAddress: string, wallet: ethers.Wallet): ethers.Contract;
+    protected getGasPriceGwei(context: TradeContext): string;
+    protected getBuilderTipAmoutGwei(context: TradeContext): string;
+    preApproveAllWallets(token_list?: string[]): Promise<void>;
+    private approveTokenIfNeeded;
+    protected checkTradeTokenApprove(context: TradeContext, wallet: ethers.Wallet, routerAddress?: string): Promise<void>;
+    protected checkTokenApprove(tokenAddress: string, tokenSymbol: string, tokenContract: ethers.Contract, spenderAddress: string, wallet: ethers.Wallet): 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, wallet: ethers.Wallet): Promise<string>;
+}

package/dist/trade/abstract_dex_trade_plus.js

@@ -0,0 +1,227 @@
+"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.AbstractEvmDexTradePlus = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const ethers_1 = require("ethers");
+const common_1 = require("../common");
+class AbstractEvmDexTradePlus extends dist_1.AbastrcatTrade {
+    constructor(appConfig) {
+        super();
+        this.appConfig = appConfig;
+        this.approvedTokens = new Map();
+        this.pairContracts = new Map();
+        this.tokenContracts = new Map();
+        this.approvedTokens = new Map();
+        this.pairContracts = new Map();
+        this.tokenContracts = new Map();
+        this.initConfigs();
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.provider = new ethers_1.ethers.providers.JsonRpcProvider(this.chainConfig.rpcEndpoint);
+            if (!process.env.WALLET_GROUP_IDS) {
+                throw new Error('必须配置 WALLET_GROUP_IDS 环境变量来启用多钱包功能');
+            }
+            let wallet_infos = (0, dist_1.load_wallet_multi)(((_a = process.env.WALLET_GROUP_IDS) === null || _a === void 0 ? void 0 : _a.split(',')) || [], false);
+            this.group_wallets = wallet_infos.map(info => new ethers_1.ethers.Wallet(info.private_key, this.provider));
+            (0, dist_1.log_info)(`组钱包已初始化，数量: ${this.group_wallets.length}`, this.group_wallets.map(e => e.address));
+            this.routerContract = new ethers_1.ethers.Contract(this.dexConfig.routerAddress, this.dexConfig.routerAbi, this.provider);
+            (0, dist_1.log_info)(`${this.dexConfig.dexName} Router已初始化, 地址: ${this.dexConfig.routerAddress}, 钱包数量: ${this.group_wallets.length}`);
+        });
+    }
+    getTokenContract(tokenAddress) {
+        if (!this.tokenContracts.has(tokenAddress)) {
+            const tokenContract = new ethers_1.ethers.Contract(tokenAddress, common_1.ERC20_ABI, this.provider);
+            this.tokenContracts.set(tokenAddress, tokenContract);
+        }
+        return this.tokenContracts.get(tokenAddress);
+    }
+    getTokenContractWithWallet(tokenAddress, wallet) {
+        const tokenContract = this.getTokenContract(tokenAddress);
+        return tokenContract.connect(wallet);
+    }
+    getGasPriceGwei(context) {
+        let { evm_gas_limit, evm_gas_price_gwei, evm_tip_amount_gwei } = context.trade_runtime.settings.strategy;
+        if (evm_gas_price_gwei === undefined || evm_gas_price_gwei === null || evm_gas_price_gwei <= 0) {
+            evm_gas_price_gwei = this.chainConfig.gasOptions.defaultGasPriceGwei;
+        }
+        (0, dist_1.log_info)(`getGasPriceGwei: ${evm_gas_price_gwei} Gwei`);
+        return evm_gas_price_gwei.toString();
+    }
+    getBuilderTipAmoutGwei(context) {
+        let { evm_gas_limit, evm_gas_price_gwei, evm_tip_amount_gwei } = context.trade_runtime.settings.strategy;
+        if (evm_tip_amount_gwei === undefined || evm_tip_amount_gwei === null || evm_tip_amount_gwei <= 0) {
+            evm_tip_amount_gwei = this.chainConfig.gasOptions.defaultTipAmountGwei;
+        }
+        (0, dist_1.log_info)(`getGasTipAmoutGwei: ${evm_tip_amount_gwei} Gwei`);
+        return evm_tip_amount_gwei.toString();
+    }
+    preApproveAllWallets() {
+        return __awaiter(this, arguments, void 0, function* (token_list = []) {
+            if (!this.group_wallets || this.group_wallets.length === 0) {
+                (0, dist_1.log_info)('No wallets available for pre-approval');
+                return;
+            }
+            if (!token_list || token_list.length === 0) {
+                token_list = Array.from(this.tokenContracts.keys());
+            }
+            (0, dist_1.log_info)(`Pre-approve: ${this.group_wallets.length} wallets, ${token_list.length} tokens`, token_list);
+            const tokenAddresses = new Set();
+            for (const token_address of token_list) {
+                tokenAddresses.add(token_address.toLowerCase());
+            }
+            const tokens = Array.from(tokenAddresses);
+            for (const wallet of this.group_wallets) {
+                try {
+                    (0, dist_1.log_info)(`Pre-approve: wallet ${wallet.address}`);
+                    for (const tokenAddress of tokens) {
+                        try {
+                            yield this.approveTokenIfNeeded(wallet, tokenAddress);
+                        }
+                        catch (error) {
+                            console.warn(`Failed to pre-approve token ${tokenAddress} for wallet ${wallet.address}:`, error);
+                        }
+                    }
+                    (0, dist_1.log_info)(`Pre-approve: wallet ${wallet.address} completed`);
+                }
+                catch (error) {
+                    console.warn(`Failed to pre-approve tokens for wallet ${wallet.address}:`, error);
+                }
+            }
+            (0, dist_1.log_info)('Pre-approve: all wallets completed');
+        });
+    }
+    approveTokenIfNeeded(wallet, tokenAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const tokenContract = this.getTokenContract(tokenAddress);
+                const routerAddress = this.dexConfig.routerAddress;
+                const currentAllowance = yield tokenContract.allowance(wallet.address, routerAddress);
+                if (currentAllowance.gt(0)) {
+                    (0, dist_1.log_info)(`Pre-approve: token ${tokenAddress} already approved`);
+                    return;
+                }
+                const maxAllowance = ethers_1.ethers.constants.MaxUint256;
+                const approveTx = yield tokenContract.connect(wallet).approve(routerAddress, maxAllowance);
+                (0, dist_1.log_info)(`Pre-approve: token ${tokenAddress} approve success, tx: ${approveTx.hash}`);
+                yield approveTx.wait();
+                (0, dist_1.log_info)(`Pre-approve: token ${tokenAddress} approved successfully`);
+            }
+            catch (error) {
+                console.warn(`Failed to approve token ${tokenAddress} for wallet ${wallet.address}:`, error);
+                throw error;
+            }
+        });
+    }
+    checkTradeTokenApprove(context, wallet, routerAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { pool_info } = context;
+            const { tokenA, tokenB } = pool_info;
+            const router = routerAddress || this.dexConfig.routerAddress;
+            if (!this.approvedTokens.has(wallet.address)) {
+                this.approvedTokens.set(wallet.address, new Map());
+            }
+            yield Promise.all([tokenA, tokenB].map((_a) => __awaiter(this, [_a], void 0, function* ({ symbol, address }) {
+                const tokenContract = this.getTokenContractWithWallet(address, wallet);
+                yield this.checkTokenApprove(address, symbol, tokenContract, router, wallet);
+            })));
+        });
+    }
+    checkTokenApprove(tokenAddress, tokenSymbol, tokenContract, spenderAddress, wallet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.approvedTokens.has(wallet.address)) {
+                this.approvedTokens.set(wallet.address, new Map());
+            }
+            if (this.approvedTokens.get(wallet.address).get(tokenAddress)) {
+                (0, dist_1.log_info)(`钱包 ${wallet.address} 的代币 ${tokenSymbol} 已授权，跳过授权检查`);
+                return true;
+            }
+            const allowance = yield tokenContract.allowance(wallet.address, spenderAddress);
+            const maxAllowance = ethers_1.ethers.constants.MaxUint256.div(2);
+            (0, dist_1.log_info)(`代币授权检查:`, {
+                walletAddress: wallet.address,
+                tokenSymbol,
+                currentAllowance: allowance.toString(),
+                maxAllowance: maxAllowance.toString(),
+                isSufficient: allowance.gte(maxAllowance)
+            });
+            if (allowance.lt(maxAllowance)) {
+                const maxApprovalAmount = ethers_1.ethers.utils.formatUnits(ethers_1.ethers.constants.MaxUint256, yield tokenContract.decimals());
+                const tokenSymbolDisplay = tokenSymbol || `${tokenAddress.substring(0, 6)}...`;
+                (0, dist_1.log_info)(`正在为钱包 ${wallet.address} 授权代币 ${tokenSymbolDisplay}`, {
+                    walletAddress: wallet.address,
+                    tokenAddress,
+                    tokenSymbol: tokenSymbolDisplay,
+                    currentAllowance: ethers_1.ethers.utils.formatUnits(allowance, yield tokenContract.decimals()),
+                    newAllowance: maxApprovalAmount
+                });
+                const tx = yield tokenContract.approve(spenderAddress, ethers_1.ethers.constants.MaxUint256, {
+                    gasLimit: this.chainConfig.gasOptions.gasLimit
+                });
+                yield tx.wait();
+                this.approvedTokens.get(wallet.address).set(tokenAddress, true);
+                (0, dist_1.log_info)(`钱包 ${wallet.address} 的代币 ${tokenSymbolDisplay} 授权完成，数量: ${maxApprovalAmount} ${tokenSymbolDisplay}, 交易哈希: ${tx.hash}`);
+                return true;
+            }
+            else {
+                this.approvedTokens.get(wallet.address).set(tokenAddress, true);
+                return true;
+            }
+        });
+    }
+    isNonceRelatedError(error) {
+        if (!error)
+            return false;
+        const errorMessage = error.message ? error.message.toLowerCase() : '';
+        const nonceErrorKeywords = [
+            'nonce',
+            'nonce too low',
+            'nonce too high',
+            'nonce has already been used',
+            'already known',
+            'replacement transaction underpriced',
+            'transaction with same nonce',
+            'transaction nonce is too low',
+            'invalid transaction nonce',
+            'insufficient funds',
+            'sign bundle to get failure details',
+        ];
+        return nonceErrorKeywords.some(keyword => errorMessage.includes(keyword));
+    }
+    isNativeCurrency(symbol) {
+        return symbol.toUpperCase() === this.chainConfig.nativeCurrency;
+    }
+    getWrappedNativeAddress() {
+        return this.chainConfig.wrappedNativeCurrencyAddress;
+    }
+    buildTipTransferTx(to, transfer_amount_gwei, gas_price_gwei, transfer_nonce, wallet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let real_transfer_amount_gwei = Math.min(Number(transfer_amount_gwei), this.chainConfig.gasOptions.maxTipAmountGwei).toString();
+            let real_gas_price_gwei = Math.min(Number(gas_price_gwei), this.chainConfig.gasOptions.maxGasPriceGwei).toString();
+            let tx_data = {
+                from: wallet.address,
+                to,
+                value: ethers_1.ethers.utils.parseUnits(real_transfer_amount_gwei, 'gwei'),
+                gasLimit: 21000,
+                gasPrice: ethers_1.ethers.utils.parseUnits(real_gas_price_gwei, 'gwei'),
+                nonce: transfer_nonce,
+                chainId: this.chainConfig.chainId
+            };
+            let signedTx = yield wallet.signTransaction(tx_data);
+            (0, dist_1.log_info)(`构建转账交易: `, Object.assign(Object.assign({}, tx_data), { real_transfer_amount_gwei,
+                real_gas_price_gwei, txhash: ethers_1.ethers.utils.keccak256(signedTx) }));
+            return signedTx;
+        });
+    }
+}
+exports.AbstractEvmDexTradePlus = AbstractEvmDexTradePlus;

package/dist/trade/check/index.d.ts

@@ -0,0 +1 @@
+export * from "./tx_websocket_manager";

package/dist/trade/check/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("./tx_websocket_manager"), exports);

package/dist/trade/check/tx_websocket_manager.d.ts

@@ -0,0 +1,23 @@
+import { ethers } from 'ethers';
+export declare class WebSocketManager {
+    private static instance;
+    private wsProvider;
+    private wsConnections;
+    private reconnectAttempts;
+    private readonly MAX_RECONNECT_ATTEMPTS;
+    private readonly RECONNECT_DELAY;
+    private reconnecting;
+    private eventListeners;
+    private constructor();
+    static getInstance(): WebSocketManager;
+    getWsProvider(wsEndpoint: string, network: {
+        name: string;
+        chainId: number;
+    }): ethers.providers.WebSocketProvider | null;
+    private handleWsError;
+    private handleWsDisconnection;
+    incrementConnections(): void;
+    decrementConnections(): void;
+    listenToEvent(eventName: string, handler: Function): void;
+    removeEventListener(eventName: string, handler: Function): void;
+}

package/dist/trade/check/tx_websocket_manager.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketManager = void 0;
+const ethers_1 = require("ethers");
+const dist_1 = require("@clonegod/ttd-core/dist");
+class WebSocketManager {
+    constructor() {
+        this.wsProvider = null;
+        this.wsConnections = 0;
+        this.reconnectAttempts = 0;
+        this.MAX_RECONNECT_ATTEMPTS = 5;
+        this.RECONNECT_DELAY = 2000;
+        this.reconnecting = false;
+        this.eventListeners = new Map();
+    }
+    static getInstance() {
+        if (!WebSocketManager.instance) {
+            WebSocketManager.instance = new WebSocketManager();
+        }
+        return WebSocketManager.instance;
+    }
+    getWsProvider(wsEndpoint, network) {
+        if (!wsEndpoint) {
+            (0, dist_1.log_warn)('WebSocket endpoint not configured');
+            return null;
+        }
+        if (!this.wsProvider && !this.reconnecting) {
+            (0, dist_1.log_info)('Creating new WebSocket provider');
+            try {
+                this.wsProvider = new ethers_1.ethers.providers.WebSocketProvider(wsEndpoint, network);
+                this.wsProvider.on('error', (error) => {
+                    this.handleWsError(error, wsEndpoint, network);
+                });
+                this.wsProvider._websocket.on('close', () => {
+                    (0, dist_1.log_warn)('WebSocket connection closed');
+                    this.handleWsDisconnection(wsEndpoint, network);
+                });
+                this.reconnectAttempts = 0;
+            }
+            catch (error) {
+                (0, dist_1.log_error)('Failed to create WebSocket provider', error);
+                this.wsProvider = null;
+            }
+        }
+        return this.wsProvider;
+    }
+    handleWsError(error, wsEndpoint, network) {
+        (0, dist_1.log_error)('WebSocket provider error', error);
+        this.handleWsDisconnection(wsEndpoint, network);
+    }
+    handleWsDisconnection(wsEndpoint, network) {
+        if (this.reconnecting)
+            return;
+        if (this.wsProvider) {
+            this.wsProvider.removeAllListeners();
+            this.wsProvider = null;
+        }
+        if (this.wsConnections > 0 &&
+            this.reconnectAttempts < this.MAX_RECONNECT_ATTEMPTS) {
+            this.reconnecting = true;
+            this.reconnectAttempts++;
+            (0, dist_1.log_info)(`Attempting to reconnect WebSocket (${this.reconnectAttempts}/${this.MAX_RECONNECT_ATTEMPTS})`);
+            setTimeout(() => {
+                this.reconnecting = false;
+                this.getWsProvider(wsEndpoint, network);
+            }, this.RECONNECT_DELAY * this.reconnectAttempts);
+        }
+        else if (this.reconnectAttempts >= this.MAX_RECONNECT_ATTEMPTS) {
+            (0, dist_1.log_error)(`Maximum WebSocket reconnection attempts (${this.MAX_RECONNECT_ATTEMPTS}) reached`, new Error('Max reconnect attempts'));
+            this.wsConnections = 0;
+            this.reconnectAttempts = 0;
+            this.reconnecting = false;
+        }
+    }
+    incrementConnections() {
+        this.wsConnections++;
+        (0, dist_1.log_info)(`WebSocket active connections: ${this.wsConnections}`);
+    }
+    decrementConnections() {
+        if (this.wsConnections > 0) {
+            this.wsConnections--;
+        }
+        (0, dist_1.log_info)(`WebSocket active connections: ${this.wsConnections}`);
+        if (this.wsConnections === 0 && this.wsProvider) {
+            (0, dist_1.log_info)('No active connections, closing WebSocket');
+            this.wsProvider.removeAllListeners();
+            this.wsProvider = null;
+            this.reconnectAttempts = 0;
+        }
+    }
+    listenToEvent(eventName, handler) {
+        var _a;
+        if (!this.wsProvider) {
+            (0, dist_1.log_warn)('WebSocket provider not available for event listener');
+            return;
+        }
+        if (!this.eventListeners.has(eventName)) {
+            this.eventListeners.set(eventName, new Set());
+        }
+        (_a = this.eventListeners.get(eventName)) === null || _a === void 0 ? void 0 : _a.add(handler);
+        this.wsProvider.once(eventName, handler);
+        this.incrementConnections();
+    }
+    removeEventListener(eventName, handler) {
+        if (!this.wsProvider)
+            return;
+        this.wsProvider.removeListener(eventName, handler);
+        const handlers = this.eventListeners.get(eventName);
+        if (handlers) {
+            handlers.delete(handler);
+            if (handlers.size === 0) {
+                this.eventListeners.delete(eventName);
+            }
+        }
+        this.decrementConnections();
+    }
+}
+exports.WebSocketManager = WebSocketManager;
+WebSocketManager.instance = null;

package/dist/trade/index.d.ts

@@ -0,0 +1,5 @@
+export * from './send';
+export * from './parse';
+export * from './check';
+export * from './abstract_dex_trade';
+export * from './abstract_dex_trade_plus';

package/dist/trade/index.js

@@ -0,0 +1,21 @@
+"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("./send"), exports);
+__exportStar(require("./parse"), exports);
+__exportStar(require("./check"), exports);
+__exportStar(require("./abstract_dex_trade"), exports);
+__exportStar(require("./abstract_dex_trade_plus"), exports);

package/dist/trade/parse/abstract_parser.d.ts

@@ -0,0 +1,8 @@
+import { StandardPoolInfoType, StandardSwapDetailType } from '@clonegod/ttd-core';
+import { TransactionReceipt } from '@ethersproject/providers';
+export interface ITxParser {
+    parseTransaction(txReceipt: TransactionReceipt, poolInfo: StandardPoolInfoType): Promise<StandardSwapDetailType>;
+}
+export interface ITxParserFactory {
+    createParser(version: string): ITxParser;
+}

package/dist/trade/parse/abstract_parser.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/trade/parse/base_parser.d.ts

@@ -0,0 +1,19 @@
+import { StandardPoolInfoType, StandardSwapDetailType } from "@clonegod/ttd-core";
+import { TransactionReceipt } from '@ethersproject/providers';
+import { ethers } from 'ethers';
+import { ITxParser } from "./abstract_parser";
+import { ParserConfig } from "../../types";
+export declare abstract class BaseTxParser implements ITxParser {
+    protected config: ParserConfig;
+    protected provider: ethers.providers.JsonRpcProvider;
+    protected blockTimeCache: Map<number, number>;
+    protected readonly CACHE_EXPIRY: number;
+    constructor(config: ParserConfig);
+    abstract parseTransaction(txReceipt: TransactionReceipt, poolInfo: StandardPoolInfoType): Promise<StandardSwapDetailType>;
+    protected getBlockTime(blockNumber: number): Promise<number>;
+    protected calculateGasFee(txReceipt: TransactionReceipt): {
+        base_fee: number;
+        priority_fee: number;
+        total_fee: number;
+    };
+}