@clonegod/ttd-base-common 1.0.26 → 1.1.1

package/dist/quote/verify/quote_price_verify.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuotePriceVerify = void 0;
+const trade_direction_1 = require("../../utils/trade_direction");
+const ttd_core_1 = require("@clonegod/ttd-core");
+function pickMatchingTier(tiers, actualAmountIn) {
+    if (!tiers || tiers.length === 0)
+        return null;
+    if (tiers.length === 1)
+        return { tier: tiers[0], mode: 'single_tier' };
+    const sorted = [...tiers].sort((a, b) => a.amount_in - b.amount_in);
+    const top = sorted[sorted.length - 1];
+    if (actualAmountIn < sorted[0].amount_in) {
+        return { tier: sorted[0], mode: 'extrapolated_low' };
+    }
+    if (actualAmountIn > top.amount_in) {
+        return { tier: top, mode: 'extrapolated_high' };
+    }
+    for (let i = 0; i < sorted.length - 1; i++) {
+        const lower = sorted[i];
+        const upper = sorted[i + 1];
+        if (actualAmountIn >= lower.amount_in && actualAmountIn <= upper.amount_in) {
+            if (actualAmountIn === lower.amount_in)
+                return { tier: lower, mode: 'exact' };
+            if (actualAmountIn === upper.amount_in)
+                return { tier: upper, mode: 'exact' };
+            const span = upper.amount_in - lower.amount_in;
+            if (span <= 0)
+                return { tier: lower, mode: 'exact' };
+            const ratio = (actualAmountIn - lower.amount_in) / span;
+            const lerp = (a, b) => a + ratio * (b - a);
+            return {
+                tier: {
+                    pct: lerp(lower.pct, upper.pct),
+                    price: lerp(lower.price, upper.price),
+                    amount: lerp(lower.amount, upper.amount),
+                    amount_in: actualAmountIn,
+                    amount_in_usd: lerp(lower.amount_in_usd, upper.amount_in_usd),
+                    fee: lerp(lower.fee, upper.fee),
+                    fee_usd: lerp(lower.fee_usd, upper.fee_usd),
+                },
+                mode: 'interpolated',
+            };
+        }
+    }
+    return { tier: top, mode: 'extrapolated_high' };
+}
+class QuotePriceVerify {
+    constructor() {
+        this.quoteCache = new Map();
+    }
+    get enabled() {
+        return process.env.VERIFY_QUOTE_PRICE === 'true';
+    }
+    cacheQuote(poolAddress, priceId, source, askPrice, bidPrice, blockNumber, quoteAmountUsd, token0PriceUsd = 0, token1PriceUsd = 0, tiers) {
+        if (!this.enabled)
+            return;
+        if (!source)
+            return;
+        let sourceMap = this.quoteCache.get(poolAddress);
+        if (!sourceMap) {
+            sourceMap = new Map();
+            this.quoteCache.set(poolAddress, sourceMap);
+        }
+        const existing = sourceMap.get(source);
+        const verifiedReferenceBlock = (existing && existing.referenceBlock === blockNumber)
+            ? existing.verifiedReferenceBlock
+            : 0;
+        sourceMap.set(source, {
+            priceId, source, askPrice, bidPrice,
+            askTiers: tiers?.askTiers,
+            bidTiers: tiers?.bidTiers,
+            referenceBlock: blockNumber,
+            verifiedReferenceBlock,
+            quoteAmountUsd,
+            token0PriceUsd, token1PriceUsd,
+        });
+    }
+    checkSwap(params) {
+        if (!this.enabled)
+            return;
+        const { poolAddress, blockNumber, txHash, poolInfo, token0Address } = params;
+        const sourceMap = this.quoteCache.get(poolAddress);
+        if (!sourceMap || sourceMap.size === 0)
+            return;
+        const swapData = this.deriveSwapDirection(params);
+        if (!swapData)
+            return;
+        const direction = (0, trade_direction_1.resolveTradeDirection)(poolInfo, true);
+        const inputIsQuoteToken = swapData.inputTokenAddress.toLowerCase() === direction.quoteToken.address.toLowerCase();
+        const isBuy = inputIsQuoteToken;
+        const execPriceStr = (0, trade_direction_1.calculateStandardPrice)(swapData.inputAmountUi, swapData.outputAmountUi, isBuy);
+        const execPrice = Number(execPriceStr);
+        if (execPrice <= 0)
+            return;
+        const verifiable = [];
+        for (const [source, cached] of sourceMap) {
+            if (blockNumber <= cached.referenceBlock)
+                continue;
+            if (cached.verifiedReferenceBlock === cached.referenceBlock)
+                continue;
+            const tiers = isBuy ? cached.askTiers : cached.bidTiers;
+            let refPrice;
+            let tierInfo;
+            if (tiers && tiers.length > 0) {
+                const match = pickMatchingTier(tiers, swapData.inputAmountUi);
+                if (!match)
+                    continue;
+                refPrice = match.tier.price;
+                tierInfo = {
+                    matched_pct: parseFloat(match.tier.pct.toFixed(4)),
+                    mode: match.mode,
+                    tier_amount_in: match.tier.amount_in,
+                };
+            }
+            else {
+                refPrice = isBuy ? cached.askPrice : cached.bidPrice;
+            }
+            if (refPrice <= 0)
+                continue;
+            cached.verifiedReferenceBlock = cached.referenceBlock;
+            const diff_bps = (refPrice - execPrice) / refPrice * 10000;
+            verifiable.push({ source, cached, refPrice, diff_bps, tierInfo });
+        }
+        if (verifiable.length === 0)
+            return;
+        verifiable.sort((a, b) => b.cached.referenceBlock - a.cached.referenceBlock);
+        const primary = verifiable[0];
+        const sources = {};
+        for (const r of verifiable) {
+            sources[r.source] = {
+                ask: r.cached.askPrice,
+                bid: r.cached.bidPrice,
+                diff_bps: parseFloat(r.diff_bps.toFixed(1)),
+                quote_block: r.cached.referenceBlock,
+                ...(r.tierInfo && {
+                    matched_pct: r.tierInfo.matched_pct,
+                    tier_mode: r.tierInfo.mode,
+                    tier_amount_in: r.tierInfo.tier_amount_in,
+                }),
+            };
+        }
+        this.compareAndLog(poolAddress, params.poolName, poolInfo, primary.cached, swapData.inputTokenAddress, swapData.outputTokenAddress, swapData.inputAmountUi, swapData.outputAmountUi, primary.refPrice, execPrice, primary.cached.token0PriceUsd, primary.cached.token1PriceUsd, token0Address, blockNumber, txHash, sources, primary.tierInfo);
+    }
+    deriveSwapDirection(params) {
+        const { amount0, amount1, token0Address, token1Address, token0Decimals, token1Decimals } = params;
+        const sign = params.swapperDeltaConvention ? -1n : 1n;
+        const amt0 = BigInt(amount0) * sign;
+        const amt1 = BigInt(amount1) * sign;
+        if (amt0 === 0n && amt1 === 0n)
+            return null;
+        if (amt0 > 0n && amt1 < 0n) {
+            return {
+                inputTokenAddress: token0Address,
+                outputTokenAddress: token1Address,
+                inputAmountUi: Number(amt0) / Math.pow(10, token0Decimals),
+                outputAmountUi: Number(-amt1) / Math.pow(10, token1Decimals),
+            };
+        }
+        else if (amt0 < 0n && amt1 > 0n) {
+            return {
+                inputTokenAddress: token1Address,
+                outputTokenAddress: token0Address,
+                inputAmountUi: Number(amt1) / Math.pow(10, token1Decimals),
+                outputAmountUi: Number(-amt0) / Math.pow(10, token0Decimals),
+            };
+        }
+        return null;
+    }
+    compareAndLog(poolAddress, poolName, poolInfo, cached, inputTokenAddress, outputTokenAddress, inputAmountUi, outputAmountUi, refPrice, execPriceNum, token0PriceUsd, token1PriceUsd, token0Address, swapBlockNumber, txHash, sources, primaryTierInfo) {
+        if (inputAmountUi <= 0 || outputAmountUi <= 0)
+            return;
+        let swapUsd = 0;
+        if (token0PriceUsd && token1PriceUsd && token0Address) {
+            const inputIsToken0 = inputTokenAddress.toLowerCase() === token0Address.toLowerCase();
+            swapUsd = inputIsToken0
+                ? inputAmountUi * token0PriceUsd
+                : inputAmountUi * token1PriceUsd;
+        }
+        const direction = (0, trade_direction_1.resolveTradeDirection)(poolInfo, true);
+        const baseToken = direction.baseToken;
+        const quoteToken = direction.quoteToken;
+        const inputIsQuoteToken = inputTokenAddress.toLowerCase() === quoteToken.address.toLowerCase();
+        const isBuy = inputIsQuoteToken;
+        const side = isBuy ? 'BUY' : 'SELL';
+        if (refPrice <= 0 || execPriceNum <= 0)
+            return;
+        const diffBps = (refPrice - execPriceNum) / refPrice * 10000;
+        const absDiffBps = Math.abs(diffBps);
+        const status = absDiffBps < 5 ? '✅' : absDiffBps < 10 ? '⚠️' : '❌';
+        const usdStr = swapUsd > 0 ? `$${swapUsd.toFixed(0)}` : '$?';
+        const maxUsd = cached.quoteAmountUsd * 2;
+        const inRange = swapUsd <= 0 || swapUsd <= maxUsd;
+        const rangeTag = inRange ? '' : ' [out]';
+        const tradeFlow = isBuy
+            ? `${inputAmountUi.toFixed(4)} ${quoteToken.symbol} -> ${outputAmountUi.toFixed(4)} ${baseToken.symbol}`
+            : `${inputAmountUi.toFixed(4)} ${baseToken.symbol} -> ${outputAmountUi.toFixed(4)} ${quoteToken.symbol}`;
+        const quoteSrc = cached.source || '?';
+        const quoteTag = `quote[${quoteSrc} blk:${cached.referenceBlock}]`;
+        const swapBlk = swapBlockNumber || '?';
+        const swapTx = txHash ? ` ${txHash.slice(0, 10)}` : '';
+        const swapTag = `swap[blk:${swapBlk}${swapTx}]`;
+        const priceLabel = isBuy ? 'ask' : 'bid';
+        const msg = `  ↳ [Verify] ${side} ${usdStr} (${tradeFlow}) ${quoteTag} ${priceLabel}=${refPrice.toFixed(12)} vs ${swapTag} exec=${execPriceNum.toFixed(12)} diff=${diffBps > 0 ? '+' : ''}${diffBps.toFixed(1)}bps ${status}${rangeTag}`;
+        (0, ttd_core_1.log_info)(msg);
+        try {
+            (0, ttd_core_1.report_data_to_analyze)('QuoteVerify', {
+                pool_address: poolAddress,
+                pool_name: poolName,
+                price_id: cached.priceId,
+                source: cached.source,
+                quote_amount_usd: cached.quoteAmountUsd,
+                quote_block: cached.referenceBlock,
+                swap_block: swapBlockNumber,
+                tx_hash: txHash || '',
+                side,
+                ref_price: refPrice,
+                exec_price: execPriceNum,
+                diff_bps: parseFloat(diffBps.toFixed(1)),
+                swap_usd: parseFloat(swapUsd.toFixed(0)),
+                in_range: inRange,
+                input_amount: inputAmountUi,
+                output_amount: outputAmountUi,
+                input_symbol: isBuy ? quoteToken.symbol : baseToken.symbol,
+                output_symbol: isBuy ? baseToken.symbol : quoteToken.symbol,
+                status,
+                time: Date.now(),
+                sources: sources || undefined,
+                ...(primaryTierInfo && {
+                    matched_tier_pct: primaryTierInfo.matched_pct,
+                    matched_tier_mode: primaryTierInfo.mode,
+                    matched_tier_amount_in: primaryTierInfo.tier_amount_in,
+                }),
+            });
+        }
+        catch (_) {
+        }
+    }
+}
+exports.QuotePriceVerify = QuotePriceVerify;

package/dist/redis/redis_client.d.ts

@@ -1,4 +1,4 @@
-import { RedisClientType } from "redis";
+type RedisAny = any;
 export declare class SimpleRedisClient {
     private lock_prefix;
     private redisClient;
@@ -6,7 +6,7 @@ export declare class SimpleRedisClient {
     private lockRetryDelayMs;
     private lockExpireSeconds;
     constructor(lock_prefix: string);
-    getRedisClient(): Promise<RedisClientType>;
+    getRedisClient(): Promise<RedisAny>;
     private getLockKey;
     acquireLock(lock_key: string, lock_value: string, expireSeconds?: number): Promise<boolean>;
     releaseLock(lock_key: string, lock_value: string): Promise<boolean>;
@@ -19,3 +19,4 @@ export declare class SimpleRedisClient {
     hgetall(key: string): Promise<any>;
     del(key: string, field?: string): Promise<any>;
 }
+export {};

package/dist/redis/redis_client.js

@@ -1,16 +1,8 @@
 "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.SimpleRedisClient = void 0;
 const dist_1 = require("@clonegod/ttd-core/dist");
+const redis_connection_1 = require("@clonegod/ttd-core/dist/redis/redis_connection");
 class SimpleRedisClient {
     constructor(lock_prefix) {
         this.lock_prefix = lock_prefix;
@@ -19,137 +11,115 @@ class SimpleRedisClient {
         this.lockRetryDelayMs = 300;
         this.lockExpireSeconds = 3;
     }
-    getRedisClient() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.redisClient) {
-                this.redisClient = yield (0, dist_1.getRedisCache)();
-            }
-            return this.redisClient;
-        });
+    async getRedisClient() {
+        if (!this.redisClient) {
+            this.redisClient = await (0, redis_connection_1.getRedisConnection)();
+        }
+        return this.redisClient;
     }
     getLockKey(lock_identifier) {
         return `${this.lock_prefix}:lock:${lock_identifier}`;
     }
-    acquireLock(lock_key_1, lock_value_1) {
-        return __awaiter(this, arguments, void 0, function* (lock_key, lock_value, expireSeconds = this.lockExpireSeconds) {
-            const redisClient = yield this.getRedisClient();
-            const result = yield redisClient.set(lock_key, lock_value, {
-                NX: true,
-                EX: expireSeconds
-            });
-            (0, dist_1.log_info)(`try acquireLock: lock_key=${lock_key}, lock_value=${lock_value}, expireSeconds=${expireSeconds}, result=${result}`);
-            const success = result === 'OK';
-            if (success) {
-                (0, dist_1.log_info)(`acquire lock success: lock_key=${lock_key}, lock_value=${lock_value}`);
-            }
-            return success;
+    async acquireLock(lock_key, lock_value, expireSeconds = this.lockExpireSeconds) {
+        const redisClient = await this.getRedisClient();
+        const result = await redisClient.set(lock_key, lock_value, {
+            NX: true,
+            EX: expireSeconds
         });
+        (0, dist_1.log_info)(`try acquireLock: lock_key=${lock_key}, lock_value=${lock_value}, expireSeconds=${expireSeconds}, result=${result}`);
+        const success = result === 'OK';
+        if (success) {
+            (0, dist_1.log_info)(`acquire lock success: lock_key=${lock_key}, lock_value=${lock_value}`);
+        }
+        return success;
     }
-    releaseLock(lock_key, lock_value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const redisClient = yield this.getRedisClient();
-            const script = `
+    async releaseLock(lock_key, lock_value) {
+        const redisClient = await this.getRedisClient();
+        const script = `
             if redis.call('get', KEYS[1]) == ARGV[1] then
                 return redis.call('del', KEYS[1])
             else
                 return 0
             end
         `;
-            const result = yield redisClient.eval(script, {
-                keys: [lock_key],
-                arguments: [lock_value]
-            });
-            const success = Number(result) === 1;
-            if (success) {
-                (0, dist_1.log_info)(`release lock success: lock_key=${lock_key}, lock_value=${lock_value}`);
-            }
-            else {
-                (0, dist_1.log_info)(`release lock failed: lock_key=${lock_key}, lock_value=${lock_value}, maybe expired or locked by other process`);
-            }
-            return success;
+        const result = await redisClient.eval(script, {
+            keys: [lock_key],
+            arguments: [lock_value]
         });
+        const success = Number(result) === 1;
+        if (success) {
+            (0, dist_1.log_info)(`release lock success: lock_key=${lock_key}, lock_value=${lock_value}`);
+        }
+        else {
+            (0, dist_1.log_info)(`release lock failed: lock_key=${lock_key}, lock_value=${lock_value}, maybe expired or locked by other process`);
+        }
+        return success;
     }
-    withLock(lock_identifier_1, callback_1) {
-        return __awaiter(this, arguments, void 0, function* (lock_identifier, callback, release_lock_delay_ms = 2000) {
-            const lock_key = this.getLockKey(lock_identifier);
-            const lock_value = `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
-            let retries = 0;
-            let acquired = false;
-            let first_try_time = Date.now();
-            let get_lock_time = 0;
-            try {
-                while (retries < this.lockMaxRetries) {
-                    acquired = yield this.acquireLock(lock_key, lock_value);
-                    if (acquired)
-                        break;
-                    yield new Promise(resolve => setTimeout(resolve, this.lockRetryDelayMs));
-                    retries++;
-                }
-                if (acquired) {
-                    get_lock_time = Date.now();
-                    return yield callback();
-                }
+    async withLock(lock_identifier, callback, release_lock_delay_ms = 2000) {
+        const lock_key = this.getLockKey(lock_identifier);
+        const lock_value = `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+        let retries = 0;
+        let acquired = false;
+        let first_try_time = Date.now();
+        let get_lock_time = 0;
+        try {
+            while (retries < this.lockMaxRetries) {
+                acquired = await this.acquireLock(lock_key, lock_value);
+                if (acquired)
+                    break;
+                await new Promise(resolve => setTimeout(resolve, this.lockRetryDelayMs));
+                retries++;
             }
-            finally {
-                if (acquired) {
-                    const release_delay = parseInt(process.env.NONCE_LOCK_RELEASE_DELAY_MS || String(release_lock_delay_ms));
-                    yield (0, dist_1.sleep)(release_delay);
-                    yield this.releaseLock(lock_key, lock_value);
-                    (0, dist_1.log_info)(`withLock success: lock_key=${lock_key}, lock_value=${lock_value}, retry times=${retries}, get lock take ${get_lock_time - first_try_time}ms, release_delay=${release_delay}ms, hold lock ${Date.now() - get_lock_time}ms`);
-                }
-                else {
-                    (0, dist_1.log_warn)(`withLock failed: lock_key=${lock_key}, lock_value=${lock_value}, retry times=${retries}, took ${Date.now() - first_try_time}ms`);
-                }
+            if (acquired) {
+                get_lock_time = Date.now();
+                return await callback();
             }
-        });
+        }
+        finally {
+            if (acquired) {
+                const release_delay = parseInt(process.env.NONCE_LOCK_RELEASE_DELAY_MS || String(release_lock_delay_ms));
+                await (0, dist_1.sleep)(release_delay);
+                await this.releaseLock(lock_key, lock_value);
+                (0, dist_1.log_info)(`withLock success: lock_key=${lock_key}, lock_value=${lock_value}, retry times=${retries}, get lock take ${get_lock_time - first_try_time}ms, release_delay=${release_delay}ms, hold lock ${Date.now() - get_lock_time}ms`);
+            }
+            else {
+                (0, dist_1.log_warn)(`withLock failed: lock_key=${lock_key}, lock_value=${lock_value}, retry times=${retries}, took ${Date.now() - first_try_time}ms`);
+            }
+        }
     }
-    getValue(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const redisClient = yield this.getRedisClient();
-            return yield redisClient.get(key);
-        });
+    async getValue(key) {
+        const redisClient = await this.getRedisClient();
+        return await redisClient.get(key);
     }
-    setValue(key, value, expireSeconds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const redisClient = yield this.getRedisClient();
-            return yield redisClient.set(key, value, {
-                EX: expireSeconds
-            });
+    async setValue(key, value, expireSeconds) {
+        const redisClient = await this.getRedisClient();
+        return await redisClient.set(key, value, {
+            EX: expireSeconds
         });
     }
-    hsetValue(key, field, value, expireSeconds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const redisClient = yield this.getRedisClient();
-            yield redisClient.hSet(key, field, value);
-            yield redisClient.hExpire(key, field, expireSeconds);
-        });
+    async hsetValue(key, field, value, expireSeconds) {
+        const redisClient = await this.getRedisClient();
+        await redisClient.hSet(key, field, value);
+        await redisClient.hExpire(key, field, expireSeconds);
     }
-    hgetvalue(key, field) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const redisClient = yield this.getRedisClient();
-            return yield redisClient.hGet(key, field);
-        });
+    async hgetvalue(key, field) {
+        const redisClient = await this.getRedisClient();
+        return await redisClient.hGet(key, field);
     }
-    hkeys(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const redisClient = yield this.getRedisClient();
-            return yield redisClient.hKeys(key);
-        });
+    async hkeys(key) {
+        const redisClient = await this.getRedisClient();
+        return await redisClient.hKeys(key);
     }
-    hgetall(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const redisClient = yield this.getRedisClient();
-            return yield redisClient.hGetAll(key);
-        });
+    async hgetall(key) {
+        const redisClient = await this.getRedisClient();
+        return await redisClient.hGetAll(key);
     }
-    del(key_1) {
-        return __awaiter(this, arguments, void 0, function* (key, field = '') {
-            const redisClient = yield this.getRedisClient();
-            if (field) {
-                return yield redisClient.hDel(key, field);
-            }
-            return yield redisClient.del(key);
-        });
+    async del(key, field = '') {
+        const redisClient = await this.getRedisClient();
+        if (field) {
+            return await redisClient.hDel(key, field);
+        }
+        return await redisClient.del(key);
     }
 }
 exports.SimpleRedisClient = SimpleRedisClient;

package/dist/send-tx/constants.d.ts

@@ -0,0 +1,2 @@
+export declare enum BASE_EOA_ADDRESS {
+}

package/dist/send-tx/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_EOA_ADDRESS = void 0;
+var BASE_EOA_ADDRESS;
+(function (BASE_EOA_ADDRESS) {
+})(BASE_EOA_ADDRESS || (exports.BASE_EOA_ADDRESS = BASE_EOA_ADDRESS = {}));

package/dist/send-tx/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './constants';

package/dist/{config → send-tx}/index.js

@@ -14,4 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./base_env_args"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./constants"), exports);

package/dist/send-tx/types.d.ts

@@ -0,0 +1,4 @@
+import { TradeTrace } from '../trade/trade_trace';
+export interface ITransactionSender {
+    sendTransaction(signedMainTx: string, tipTxMap: Map<string, string>, order_trace_id: string, pair?: string, only_bundle?: boolean, trace?: Pick<TradeTrace, 'mark'>): Promise<string[]>;
+}

package/dist/send-tx/types.js

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

package/dist/trade/abstract_dex_trade.d.ts

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