@clonegod/ttd-base-common 1.0.26 → 1.1.2

package/dist/types/event_types.d.ts

@@ -13,9 +13,9 @@ export interface EvmContractEventData {
     eventSignature: string;
     args: any;
     removeListener: () => void;
-    getBlock: () => Promise<ethers.providers.Block>;
-    getTransaction: () => Promise<ethers.providers.TransactionResponse>;
-    getTransactionReceipt: () => Promise<ethers.providers.TransactionReceipt>;
+    getBlock: () => Promise<any>;
+    getTransaction: () => Promise<any>;
+    getTransactionReceipt: () => Promise<any>;
     decode: (data: string, topics?: string[]) => any;
 }
 export interface AmmPoolSyncEventData extends EvmContractEventData {

package/dist/types/pool_state.d.ts

@@ -2,7 +2,7 @@ export interface OnchainPoolData {
     address: string;
     token0: string;
     token1: string;
-    fee: number;
+    feeRateBps: number;
     tickSpacing: number;
     reserve0: string;
     reserve1: string;
@@ -10,20 +10,147 @@ export interface OnchainPoolData {
     sqrtPriceX96: string;
     liquidity: string;
 }
+export interface AmmPoolState {
+    address: string;
+    token0: string;
+    token1: string;
+    protocolFeeBps: number;
+    reserve0: string;
+    reserve1: string;
+    stable?: boolean;
+    decimals0?: string;
+    decimals1?: string;
+}
+export interface ClmmPoolState {
+    address: string;
+    token0: string;
+    token1: string;
+    poolFee: number;
+    tickSpacing: number;
+    tick: number;
+    sqrtPriceX96: string;
+    liquidity: string;
+}
+export interface InfinityPoolState {
+    address: string;
+    token0: string;
+    token1: string;
+    currency0: string;
+    currency1: string;
+    hooks: string;
+    poolManager: string;
+    parameters: string;
+    tickSpacing: number;
+    poolKeyFee: number;
+    tick: number;
+    sqrtPriceX96: string;
+    liquidity: string;
+    slot0LpFee?: number;
+    slot0ProtocolFee?: number;
+    lastSwapFee?: number;
+    lastSwapProtocolFee?: number;
+}
 export interface OnchainPoolChangeEvent {
+    provider_id?: string;
     pool_address: string;
     type: string;
     event_time: number;
-    data: {
-        blockNumber: number;
-        transactionIndex: number;
-        transactionHash: string;
-        amount0: string;
-        amount1: string;
-        reserve0: BigInt;
-        reserve1: BigInt;
-        tick: number;
-        sqrtPriceX96: BigInt;
-        liquidity: BigInt;
-    };
+    data: OnchainEventDataMerged;
+}
+export interface OnchainEventDataMerged {
+    blockNumber: number;
+    transactionIndex: number;
+    transactionHash: string;
+    reserve0?: string;
+    reserve1?: string;
+    amount0?: string;
+    amount1?: string;
+    sqrtPriceX96?: string;
+    liquidity?: string;
+    tick?: number;
+    protocolFeesToken0?: string;
+    protocolFeesToken1?: string;
+    fee?: string;
+    protocolFee?: string;
+    tickLower?: number;
+    tickUpper?: number;
+    amount?: string;
+    liquidityDelta?: string;
+    token0Symbol?: string;
+    token1Symbol?: string;
+    askToken0InToken1?: string;
+    bidToken0InToken1?: string;
+    askToken1InToken0?: string;
+    bidToken1InToken0?: string;
+}
+export interface V2SwapEventData {
+    blockNumber: number;
+    transactionIndex: number;
+    transactionHash: string;
+    reserve0: string;
+    reserve1: string;
+    amount0?: string;
+    amount1?: string;
+}
+export interface V2LiquidityEventData {
+    blockNumber: number;
+    transactionIndex: number;
+    transactionHash: string;
+    amount0: string;
+    amount1: string;
+}
+export interface V3SwapEventData {
+    blockNumber: number;
+    transactionIndex: number;
+    transactionHash: string;
+    amount0: string;
+    amount1: string;
+    sqrtPriceX96: string;
+    liquidity: string;
+    tick: number;
+    protocolFeesToken0: string;
+    protocolFeesToken1: string;
+}
+export interface V3LiquidityEventData {
+    blockNumber: number;
+    transactionIndex: number;
+    transactionHash: string;
+    tickLower: number;
+    tickUpper: number;
+    amount: string;
+    amount0: string;
+    amount1: string;
+}
+export interface V4SwapEventData {
+    blockNumber: number;
+    transactionIndex: number;
+    transactionHash: string;
+    amount0: string;
+    amount1: string;
+    sqrtPriceX96: string;
+    liquidity: string;
+    tick: number;
+    fee: string;
+    protocolFee: string;
+}
+export interface V4LiquidityEventData {
+    blockNumber: number;
+    transactionIndex: number;
+    transactionHash: string;
+    tickLower: number;
+    tickUpper: number;
+    amount: string;
+    amount0: string;
+    amount1: string;
+}
+export interface PriceFeedEventData {
+    blockNumber: number;
+    transactionIndex: number;
+    transactionHash: string;
+    token0Symbol: string;
+    token1Symbol: string;
+    askToken0InToken1: string;
+    bidToken0InToken1: string;
+    askToken1InToken0: string;
+    bidToken1InToken0: string;
 }

package/dist/utils/ethers_compat.d.ts

@@ -0,0 +1,13 @@
+export declare const ethersCompat: {
+    Interface: any;
+    JsonRpcProvider: any;
+    WebSocketProvider: any;
+    id: any;
+    formatUnits: any;
+    parseUnits: any;
+    formatEther: any;
+    parseEther: any;
+    keccak256: any;
+    isAddress: any;
+    Zero: any;
+};

package/dist/utils/ethers_compat.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ethersCompat = void 0;
+const ethers_1 = require("ethers");
+const _ethers = ethers_1.ethers;
+exports.ethersCompat = {
+    Interface: _ethers.utils?.Interface || _ethers.Interface,
+    JsonRpcProvider: _ethers.providers?.JsonRpcProvider || _ethers.JsonRpcProvider,
+    WebSocketProvider: _ethers.providers?.WebSocketProvider || _ethers.WebSocketProvider,
+    id: _ethers.utils?.id || _ethers.id,
+    formatUnits: _ethers.utils?.formatUnits || _ethers.formatUnits,
+    parseUnits: _ethers.utils?.parseUnits || _ethers.parseUnits,
+    formatEther: _ethers.utils?.formatEther || _ethers.formatEther,
+    parseEther: _ethers.utils?.parseEther || _ethers.parseEther,
+    keccak256: _ethers.utils?.keccak256 || _ethers.keccak256,
+    isAddress: _ethers.utils?.isAddress || _ethers.isAddress,
+    Zero: _ethers.constants?.Zero || BigInt(0),
+};

package/dist/utils/fast_signer.d.ts

@@ -0,0 +1 @@
+export declare function patchEthersV5Signer(): boolean;

package/dist/utils/fast_signer.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchEthersV5Signer = patchEthersV5Signer;
+let patchedV5 = false;
+let patchedV6 = false;
+function tryRequire(moduleName) {
+    try {
+        return require(moduleName);
+    }
+    catch {
+        return null;
+    }
+}
+function patchEthersV5Signer() {
+    const secp = tryRequire('secp256k1');
+    if (!secp) {
+        console.warn('[fast_signer] secp256k1 native module not found, skipping patch');
+        return false;
+    }
+    if (patchEthersV5WithSecp(secp))
+        return true;
+    if (patchEthersV6WithSecp(secp))
+        return true;
+    console.log('[fast_signer] no compatible ethers version found, skipping patch');
+    return false;
+}
+function patchEthersV5WithSecp(secp) {
+    if (patchedV5)
+        return true;
+    const signingKeyModule = tryRequire('@ethersproject/signing-key');
+    const bytesModule = tryRequire('@ethersproject/bytes');
+    if (!signingKeyModule || !bytesModule)
+        return false;
+    const { SigningKey } = signingKeyModule;
+    const { arrayify, hexZeroPad, splitSignature } = bytesModule;
+    const originalSignDigest = SigningKey.prototype.signDigest;
+    SigningKey.prototype.signDigest = function (digest) {
+        const privKeyBytes = arrayify(this.privateKey);
+        const digestBytes = arrayify(digest);
+        if (digestBytes.length !== 32) {
+            return originalSignDigest.call(this, digest);
+        }
+        try {
+            const { signature, recid } = secp.ecdsaSign(digestBytes, privKeyBytes);
+            const r = hexZeroPad('0x' + Buffer.from(signature.slice(0, 32)).toString('hex'), 32);
+            const s = hexZeroPad('0x' + Buffer.from(signature.slice(32, 64)).toString('hex'), 32);
+            return splitSignature({ recoveryParam: recid, r, s });
+        }
+        catch (err) {
+            console.warn('[fast_signer v5] native sign failed, fallback', err);
+            return originalSignDigest.call(this, digest);
+        }
+    };
+    patchedV5 = true;
+    console.log('[fast_signer] ethers v5 SigningKey patched with native secp256k1');
+    return true;
+}
+function patchEthersV6WithSecp(secp) {
+    if (patchedV6)
+        return true;
+    const ethersV6 = tryRequire('ethers');
+    if (!ethersV6 || !ethersV6.SigningKey || !ethersV6.Signature || !ethersV6.getBytes) {
+        return false;
+    }
+    const { SigningKey, Signature, getBytes } = ethersV6;
+    const originalSign = SigningKey.prototype.sign;
+    SigningKey.prototype.sign = function (digest) {
+        const privKeyBytes = getBytes(this.privateKey);
+        const digestBytes = getBytes(digest);
+        if (digestBytes.length !== 32) {
+            return originalSign.call(this, digest);
+        }
+        try {
+            const { signature, recid } = secp.ecdsaSign(digestBytes, privKeyBytes);
+            const r = '0x' + Buffer.from(signature.slice(0, 32)).toString('hex').padStart(64, '0');
+            const s = '0x' + Buffer.from(signature.slice(32, 64)).toString('hex').padStart(64, '0');
+            return Signature.from({ r, s, v: recid ? 0x1c : 0x1b });
+        }
+        catch (err) {
+            console.warn('[fast_signer v6] native sign failed, fallback', err);
+            return originalSign.call(this, digest);
+        }
+    };
+    patchedV6 = true;
+    console.log('[fast_signer] ethers v6 SigningKey patched with native secp256k1');
+    return true;
+}

package/dist/utils/gas_helper.d.ts

@@ -1,5 +1,5 @@
 import { ethers } from 'ethers';
 export declare class EVMGasHelper {
-    static wrapNativeToken(provider: ethers.providers.Provider, wallet: ethers.Wallet, wrappedTokenAddress: string, amount: string, minReserve?: string, tokenSymbol?: string): Promise<string>;
-    static checkNativeBalance(provider: ethers.providers.Provider, walletAddress: string): Promise<ethers.BigNumber>;
+    static wrapNativeToken(provider: any, wallet: ethers.Wallet, wrappedTokenAddress: string, amount: string, minReserve?: string, tokenSymbol?: string): Promise<string>;
+    static checkNativeBalance(provider: any, walletAddress: string): Promise<ethers.BigNumber>;
 }

package/dist/utils/gas_helper.js

@@ -1,72 +1,60 @@
 "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.EVMGasHelper = void 0;
 const ethers_1 = require("ethers");
-const dist_1 = require("@clonegod/ttd-core/dist");
+const ethers_compat_1 = require("./ethers_compat");
+const ttd_core_1 = require("@clonegod/ttd-core");
 class EVMGasHelper {
-    static wrapNativeToken(provider_1, wallet_1, wrappedTokenAddress_1, amount_1) {
-        return __awaiter(this, arguments, void 0, function* (provider, wallet, wrappedTokenAddress, amount, minReserve = "0.1", tokenSymbol = "ETH") {
-            const nativeBalance = yield provider.getBalance(wallet.address);
-            const nativeBalanceEth = ethers_1.ethers.utils.formatEther(nativeBalance);
-            (0, dist_1.log_info)(`当前${tokenSymbol}余额: ${nativeBalanceEth} ${tokenSymbol}`);
-            let wrapAmount;
-            if (amount === "max") {
-                const minReserveBN = ethers_1.ethers.utils.parseEther(minReserve);
-                if (nativeBalance.lte(minReserveBN)) {
-                    (0, dist_1.log_info)(`${tokenSymbol}余额不足最小保留额 ${minReserve} ${tokenSymbol}，不执行转换`);
-                    return null;
-                }
-                wrapAmount = nativeBalance.sub(minReserveBN);
-            }
-            else {
-                wrapAmount = ethers_1.ethers.utils.parseEther(amount);
-                const minReserveBN = ethers_1.ethers.utils.parseEther(minReserve);
-                if (nativeBalance.sub(wrapAmount).lt(minReserveBN)) {
-                    (0, dist_1.log_info)(`转换后${tokenSymbol}余额将低于最小保留额 ${minReserve} ${tokenSymbol}，调整转换金额`);
-                    wrapAmount = nativeBalance.sub(minReserveBN);
-                }
-            }
-            if (wrapAmount.lte(ethers_1.ethers.constants.Zero)) {
-                (0, dist_1.log_info)(`计算的转换金额为0或负数，不执行转换`);
+    static async wrapNativeToken(provider, wallet, wrappedTokenAddress, amount, minReserve = "0.1", tokenSymbol = "ETH") {
+        const nativeBalance = await provider.getBalance(wallet.address);
+        const nativeBalanceEth = ethers_compat_1.ethersCompat.formatEther(nativeBalance);
+        (0, ttd_core_1.log_info)(`当前${tokenSymbol}余额: ${nativeBalanceEth} ${tokenSymbol}`);
+        let wrapAmount;
+        if (amount === "max") {
+            const minReserveBN = ethers_compat_1.ethersCompat.parseEther(minReserve);
+            if (nativeBalance.lte(minReserveBN)) {
+                (0, ttd_core_1.log_info)(`${tokenSymbol}余额不足最小保留额 ${minReserve} ${tokenSymbol}，不执行转换`);
                 return null;
             }
-            const wrappedTokenContract = new ethers_1.ethers.Contract(wrappedTokenAddress, [
-                "function deposit() external payable",
-                "function withdraw(uint wad) external"
-            ], wallet);
-            (0, dist_1.log_info)(`准备将 ${ethers_1.ethers.utils.formatEther(wrapAmount)} ${tokenSymbol} 转换为 W${tokenSymbol}`);
-            const gasPrice = yield provider.getGasPrice();
-            const txOptions = {
-                value: wrapAmount,
-                gasLimit: 100000,
-                gasPrice: gasPrice
-            };
-            try {
-                const tx = yield wrappedTokenContract.deposit(txOptions);
-                (0, dist_1.log_info)(`${tokenSymbol}转换为W${tokenSymbol}交易已发送，txHash: ${tx.hash}`);
-                yield tx.wait();
-                (0, dist_1.log_info)(`${tokenSymbol}转换为W${tokenSymbol}交易已确认，txHash: ${tx.hash}`);
-                return tx.hash;
-            }
-            catch (error) {
-                (0, dist_1.log_error)(`${tokenSymbol}转换为W${tokenSymbol}失败: ${error.message}`, error);
-                throw error;
+            wrapAmount = nativeBalance.sub(minReserveBN);
+        }
+        else {
+            wrapAmount = ethers_compat_1.ethersCompat.parseEther(amount);
+            const minReserveBN = ethers_compat_1.ethersCompat.parseEther(minReserve);
+            if (nativeBalance.sub(wrapAmount).lt(minReserveBN)) {
+                (0, ttd_core_1.log_info)(`转换后${tokenSymbol}余额将低于最小保留额 ${minReserve} ${tokenSymbol}，调整转换金额`);
+                wrapAmount = nativeBalance.sub(minReserveBN);
             }
-        });
+        }
+        if (wrapAmount.lte(ethers_compat_1.ethersCompat.Zero)) {
+            (0, ttd_core_1.log_info)(`计算的转换金额为0或负数，不执行转换`);
+            return null;
+        }
+        const wrappedTokenContract = new ethers_1.ethers.Contract(wrappedTokenAddress, [
+            "function deposit() external payable",
+            "function withdraw(uint wad) external"
+        ], wallet);
+        (0, ttd_core_1.log_info)(`准备将 ${ethers_compat_1.ethersCompat.formatEther(wrapAmount)} ${tokenSymbol} 转换为 W${tokenSymbol}`);
+        const gasPrice = await provider.getGasPrice();
+        const txOptions = {
+            value: wrapAmount,
+            gasLimit: 100000,
+            gasPrice: gasPrice
+        };
+        try {
+            const tx = await wrappedTokenContract.deposit(txOptions);
+            (0, ttd_core_1.log_info)(`${tokenSymbol}转换为W${tokenSymbol}交易已发送，txHash: ${tx.hash}`);
+            await tx.wait();
+            (0, ttd_core_1.log_info)(`${tokenSymbol}转换为W${tokenSymbol}交易已确认，txHash: ${tx.hash}`);
+            return tx.hash;
+        }
+        catch (error) {
+            (0, ttd_core_1.log_error)(`${tokenSymbol}转换为W${tokenSymbol}失败: ${error.message}`, error);
+            throw error;
+        }
     }
-    static checkNativeBalance(provider, walletAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield provider.getBalance(walletAddress);
-        });
+    static async checkNativeBalance(provider, walletAddress) {
+        return await provider.getBalance(walletAddress);
     }
 }
 exports.EVMGasHelper = EVMGasHelper;

package/dist/utils/index.d.ts

@@ -1,7 +1,10 @@
-import { ethers } from "ethers";
 import Decimal from "decimal.js";
 export * from './gas_helper';
+export * from './trade_direction';
+export * from './pool_filter';
+export * from './ethers_compat';
+export * from './fast_signer';
 export declare const sleep: (ms: number) => Promise<void>;
 export declare const formatPrice: (price: number, precision?: number) => string;
-export declare const formatUnits: (value: ethers.BigNumber, decimals: number) => Decimal;
+export declare const formatUnits: (value: any, decimals: number) => Decimal;
 export declare const formatNumberHighPrecision: (numStr: string, precision?: number) => string;

package/dist/utils/index.js

@@ -18,9 +18,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatNumberHighPrecision = exports.formatUnits = exports.formatPrice = exports.sleep = void 0;
-const ethers_1 = require("ethers");
 const decimal_js_1 = __importDefault(require("decimal.js"));
+const ethers_compat_1 = require("./ethers_compat");
 __exportStar(require("./gas_helper"), exports);
+__exportStar(require("./trade_direction"), exports);
+__exportStar(require("./pool_filter"), exports);
+__exportStar(require("./ethers_compat"), exports);
+__exportStar(require("./fast_signer"), exports);
 const sleep = (ms) => {
     return new Promise(resolve => setTimeout(resolve, ms));
 };
@@ -30,7 +34,7 @@ const formatPrice = (price, precision = 10) => {
 };
 exports.formatPrice = formatPrice;
 const formatUnits = (value, decimals) => {
-    return new decimal_js_1.default(ethers_1.ethers.utils.formatUnits(value, decimals).toString());
+    return new decimal_js_1.default(ethers_compat_1.ethersCompat.formatUnits(value, decimals).toString());
 };
 exports.formatUnits = formatUnits;
 const formatNumberHighPrecision = (numStr, precision = 12) => {

package/dist/utils/pool_filter.d.ts

@@ -0,0 +1,8 @@
+import { StandardPoolInfoType } from '@clonegod/ttd-core';
+export interface PoolFilterParams {
+    poolAddress?: string;
+    poolName?: string;
+    feeRate?: number;
+}
+export declare function buildPoolFilterFromEnv(envArgs: any): PoolFilterParams;
+export declare function filterPools(pools: StandardPoolInfoType[], filter: PoolFilterParams, label?: string): StandardPoolInfoType[];

package/dist/utils/pool_filter.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPoolFilterFromEnv = buildPoolFilterFromEnv;
+exports.filterPools = filterPools;
+const ttd_core_1 = require("@clonegod/ttd-core");
+function buildPoolFilterFromEnv(envArgs) {
+    return {
+        poolAddress: envArgs.quote_pool_address || undefined,
+        poolName: envArgs.quote_pool_name || undefined,
+        feeRate: envArgs.quote_pool_fee_rate || undefined,
+    };
+}
+function filterPools(pools, filter, label = '') {
+    const prefix = label ? `[${label}] ` : '';
+    let result = pools;
+    if (filter.poolAddress) {
+        result = pools.filter(p => p.pool_address.toLowerCase() === filter.poolAddress.toLowerCase());
+    }
+    else if (filter.poolName || filter.feeRate) {
+        result = pools.filter(p => {
+            if (filter.poolName && p.pool_name !== filter.poolName)
+                return false;
+            if (filter.feeRate && p.fee_rate !== filter.feeRate)
+                return false;
+            return true;
+        });
+    }
+    if (result.length === 0 && pools.length > 0) {
+        (0, ttd_core_1.log_warn)(`${prefix}Pool filter matched 0 pools from ${pools.length}`, {
+            filter,
+            available: pools.map(p => `${p.pool_name}(${p.pool_address}, fee=${p.fee_rate})`),
+        });
+    }
+    else {
+        (0, ttd_core_1.log_info)(`${prefix}Pool filter: ${pools.length} → ${result.length}`, result.map(p => `${p.pool_name}(${p.pool_address}, fee=${p.fee_rate})`));
+    }
+    return result;
+}

package/dist/utils/trade_direction.d.ts

@@ -0,0 +1,14 @@
+export interface TradeDirectionResult<T = any> {
+    isBuy: boolean;
+    inputToken: T;
+    outputToken: T;
+    baseToken: T;
+    quoteToken: T;
+}
+export declare function resolveTradeDirection<T = any>(poolInfo: {
+    tokenA: T;
+    tokenB: T;
+    quote_token: string;
+    [key: string]: any;
+}, isBuy: boolean): TradeDirectionResult<T>;
+export declare function calculateStandardPrice(inputAmount: number, outputAmount: number, isBuy: boolean): string;

package/dist/utils/trade_direction.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTradeDirection = resolveTradeDirection;
+exports.calculateStandardPrice = calculateStandardPrice;
+function resolveTradeDirection(poolInfo, isBuy) {
+    const { tokenA, tokenB, quote_token } = poolInfo;
+    const quoteToken = [tokenA, tokenB].find(t => t.symbol === quote_token);
+    const baseToken = [tokenA, tokenB].find(t => t.symbol !== quote_token);
+    if (!quoteToken || !baseToken) {
+        throw new Error(`Cannot resolve tokens: tokenA=${tokenA?.symbol}, tokenB=${tokenB?.symbol}, quote_token=${quote_token}`);
+    }
+    const inputToken = isBuy ? quoteToken : baseToken;
+    const outputToken = isBuy ? baseToken : quoteToken;
+    return { isBuy, inputToken, outputToken, baseToken, quoteToken };
+}
+function calculateStandardPrice(inputAmount, outputAmount, isBuy) {
+    if (isBuy) {
+        return (inputAmount / outputAmount).toFixed(18);
+    }
+    else {
+        return (outputAmount / inputAmount).toFixed(18);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-base-common",
-  "version": "1.0.26",
+  "version": "1.1.2",
   "description": "Base common library",
   "license": "UNLICENSED",
   "main": "dist/index.js",
@@ -14,8 +14,8 @@
     "push": "npm run build && npm publish"
   },
   "dependencies": {
-    "@clonegod/ttd-core": "2.1.31",
-    "axios": "^1.12.0",
+    "@clonegod/ttd-core": "3.1.75",
+    "axios": "1.15.0",
     "dotenv": "^16.4.7",
     "ethers": "^5.8.0"
   },

package/dist/config/base_env_args.d.ts

@@ -1,11 +0,0 @@
-import { EnvArgs } from "@clonegod/ttd-core/dist";
-export declare class BaseEnvArgs extends EnvArgs {
-    large_trade_threshold_usd: number;
-    gas_price_gwei: number;
-    gas_limit: number;
-    tip_amount_gwei: number;
-    tx_status_check_interval_mills: number;
-    tx_cancel_timeout_ms: number;
-    tx_cancel_gas_boost_factor: number;
-    constructor();
-}

package/dist/config/base_env_args.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEnvArgs = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
-const decimal_js_1 = require("decimal.js");
-class BaseEnvArgs extends dist_1.EnvArgs {
-    constructor() {
-        super();
-        this.large_trade_threshold_usd = parseInt(process.env.LARGE_TRADE_THRESHOLD_USD || '500');
-        this.gas_price_gwei = new decimal_js_1.Decimal(process.env.GAS_PRICE_GWEI || '1').toNumber();
-        this.gas_limit = parseInt(process.env.GAS_LIMIT || '300000');
-        this.tip_amount_gwei = parseInt(process.env.EOA_TIP_AMOUNT_GWEI || '10000');
-        this.tx_status_check_interval_mills = parseInt(process.env.TX_STATUS_CHECK_INTERVAL_MILLS || '3000');
-        this.tx_cancel_timeout_ms = parseInt(process.env.TX_CANCEL_TIMEOUT_MS || '15000');
-        this.tx_cancel_gas_boost_factor = new decimal_js_1.Decimal(process.env.TX_CANCEL_GAS_PRICE_BOOST_FACTOR || '1.5').toNumber();
-        this.print();
-    }
-}
-exports.BaseEnvArgs = BaseEnvArgs;

package/dist/config/index.d.ts

@@ -1 +0,0 @@
-export * from './base_env_args';

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

@@ -1 +0,0 @@
-export {};