@clonegod/ttd-bsc-common 3.1.77 → 3.1.79

package/dist/appconfig/bsc_dex_env_args.js

@@ -30,6 +30,10 @@ class BscDexEnvArgs extends bsc_env_args_1.BscEnvArgs {
         this.gas_price_gwei = cfg.gas_price_gwei;
         this.gas_limit = cfg.gas_limit;
         this.tip_amount_gwei = cfg.tip_amount_gwei;
+        this.gas_max_price_gwei = cfg.gas_max_price_gwei;
+        this.gas_max_fee_per_gas_gwei = cfg.gas_max_fee_per_gas_gwei;
+        this.gas_max_priority_fee_gwei = cfg.gas_max_priority_fee_gwei;
+        this.gas_max_tip_amount_gwei = cfg.gas_max_tip_amount_gwei;
         this.pancake_executor_id = cfg.pancake_executor_id;
         this.uniswap_executor_id = cfg.uniswap_executor_id;
         this.caller_select_strategy = cfg.caller_select_strategy;
@@ -41,7 +45,6 @@ class BscDexEnvArgs extends bsc_env_args_1.BscEnvArgs {
         this.send_tx_default_rpc = cfg.send_tx_default_rpc;
         this.send_tx_blockrazor_private = cfg.send_tx_blockrazor_private;
         this.send_tx_48club_private = cfg.send_tx_48club_private;
-        this.bsc_rpc_endpoint = cfg.bsc_rpc_endpoint;
         this.blockrazor_rpc_url = cfg.blockrazor_rpc_url;
         this.blockrazor_auth_token = cfg.blockrazor_auth_token;
         this._48club_rpc_url = cfg._48club_rpc_url;

package/dist/appconfig/bsc_env_args.d.ts

@@ -3,6 +3,10 @@ export declare class BscEnvArgs extends EnvArgs {
     gas_price_gwei: number;
     gas_limit: number;
     tip_amount_gwei: number;
+    gas_max_price_gwei: number;
+    gas_max_fee_per_gas_gwei: number;
+    gas_max_priority_fee_gwei: number;
+    gas_max_tip_amount_gwei: number;
     pancake_executor_id: string;
     uniswap_executor_id: string;
     caller_select_strategy: string;
@@ -14,7 +18,6 @@ export declare class BscEnvArgs extends EnvArgs {
     send_tx_default_rpc: boolean;
     send_tx_blockrazor_private: boolean;
     send_tx_48club_private: boolean;
-    bsc_rpc_endpoint: string;
     blockrazor_rpc_url: string;
     blockrazor_auth_token: string;
     _48club_rpc_url: string;

package/dist/appconfig/bsc_env_args.js

@@ -7,6 +7,10 @@ const constants_1 = require("../common/constants");
     gas_price_gwei: { env: 'GAS_PRICE_GWEI', type: 'number', default: 1, desc: '交易 gas 价格(Gwei)' },
     gas_limit: { env: 'GAS_LIMIT', type: 'number', default: 300000, desc: '交易 gas 上限' },
     tip_amount_gwei: { env: 'TIP_AMOUNT_GWEI', type: 'number', default: 10000, desc: 'Builder tip(Gwei)' },
+    gas_max_price_gwei: { env: 'GAS_MAX_PRICE_GWEI', type: 'number', default: 10, desc: 'Legacy gasPrice 上限(Gwei)' },
+    gas_max_fee_per_gas_gwei: { env: 'GAS_MAX_FEE_PER_GAS_GWEI', type: 'number', default: 10, desc: 'EIP-1559 maxFeePerGas 上限(Gwei)' },
+    gas_max_priority_fee_gwei: { env: 'GAS_MAX_PRIORITY_FEE_GWEI', type: 'number', default: 3, desc: 'EIP-1559 maxPriorityFeePerGas 上限(Gwei)' },
+    gas_max_tip_amount_gwei: { env: 'GAS_MAX_TIP_AMOUNT_GWEI', type: 'number', default: 500000, desc: 'Builder tip 上限(Gwei)' },
     pancake_executor_id: { env: 'PANCAKE_EXECUTOR_ID', type: 'string', default: 'PANCAKE', desc: 'Vault 中 Pancake executor 注册名（keccak256 后作为 bytes32）' },
     uniswap_executor_id: { env: 'UNISWAP_EXECUTOR_ID', type: 'string', default: 'UNISWAP', desc: 'Vault 中 Uniswap executor 注册名（keccak256 后作为 bytes32）' },
     caller_select_strategy: { env: 'CALLER_SELECT_STRATEGY', type: 'string', default: 'lock', desc: 'CallerManager LRU 选择策略：lock=Redis 分布式锁(默认) | lua_cas=Lua 原子脚本(单 RTT，无锁重试)' },
@@ -18,7 +22,6 @@ const constants_1 = require("../common/constants");
     send_tx_default_rpc: { env: 'SEND_TX_DEFAULT_RPC', type: 'boolean', default: false, desc: '默认 RPC 私有发送（HTTP，trader 直发）' },
     send_tx_blockrazor_private: { env: 'SEND_TX_BLOCKRAZOR_PRIVATE', type: 'boolean', default: false, desc: 'BlockRazor 私有发送（HTTP，trader 直发）' },
     send_tx_48club_private: { env: 'SEND_TX_48CLUB_PRIVATE', type: 'boolean', default: false, desc: '48Club 私有发送（HTTP，trader 直发）' },
-    bsc_rpc_endpoint: { env: 'BSC_RPC_ENDPOINT', type: 'string', default: '', desc: 'BSC RPC 端点（default_rpc HTTP 直发用）' },
     blockrazor_rpc_url: { env: 'BLOCKRAZOR_RPC_URL', type: 'string', default: 'https://rpc.blockrazor.builders', desc: 'BlockRazor RPC URL（HTTP 直发用）' },
     blockrazor_auth_token: { env: 'BLOCKRAZOR_AUTH_TOKEN', type: 'string', default: '', sensitive: true, desc: 'BlockRazor 认证 Token（HTTP 直发用）' },
     _48club_rpc_url: { env: '_48CLUB_RPC_URL', type: 'string', default: 'https://puissant-builder.48.club/', desc: '48Club RPC URL（HTTP 直发用）' },

package/dist/common/abi.d.ts

@@ -1,31 +1,3 @@
 export declare const ERC20_ABI: string[];
-export declare const PANCAKE_PAIR_FULL_ABI: ({
-    anonymous: boolean;
-    inputs: {
-        indexed: boolean;
-        internalType: string;
-        name: string;
-        type: string;
-    }[];
-    name: string;
-    type: string;
-    constant?: undefined;
-    outputs?: undefined;
-    payable?: undefined;
-    stateMutability?: undefined;
-} | {
-    constant: boolean;
-    inputs: any[];
-    name: string;
-    outputs: {
-        internalType: string;
-        name: string;
-        type: string;
-    }[];
-    payable: boolean;
-    stateMutability: string;
-    type: string;
-    anonymous?: undefined;
-})[];
 export declare const PANCAKE_V2_ROUTER_ABI: string[];
-export declare const PANCAKE_V3_ROUTER_ABI: string[];
+export declare const PancakeV3PoolABI: string[];

package/dist/common/abi.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PANCAKE_V3_ROUTER_ABI = exports.PANCAKE_V2_ROUTER_ABI = exports.PANCAKE_PAIR_FULL_ABI = exports.ERC20_ABI = void 0;
+exports.PancakeV3PoolABI = exports.PANCAKE_V2_ROUTER_ABI = exports.ERC20_ABI = void 0;
 exports.ERC20_ABI = [
     'function decimals() view returns (uint8)',
     'function symbol() view returns (string)',
@@ -12,57 +12,20 @@ exports.ERC20_ABI = [
     'function approve(address spender, uint256 amount) returns (bool)',
     'function transferFrom(address sender, address recipient, uint256 amount) returns (bool)'
 ];
-exports.PANCAKE_PAIR_FULL_ABI = [
-    {
-        "anonymous": false,
-        "inputs": [
-            { "indexed": false, "internalType": "uint112", "name": "reserve0", "type": "uint112" },
-            { "indexed": false, "internalType": "uint112", "name": "reserve1", "type": "uint112" }
-        ],
-        "name": "Sync",
-        "type": "event"
-    },
-    {
-        "constant": true,
-        "inputs": [],
-        "name": "token0",
-        "outputs": [{ "internalType": "address", "name": "", "type": "address" }],
-        "payable": false,
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "constant": true,
-        "inputs": [],
-        "name": "token1",
-        "outputs": [{ "internalType": "address", "name": "", "type": "address" }],
-        "payable": false,
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "constant": true,
-        "inputs": [],
-        "name": "getReserves",
-        "outputs": [
-            { "internalType": "uint112", "name": "_reserve0", "type": "uint112" },
-            { "internalType": "uint112", "name": "_reserve1", "type": "uint112" },
-            { "internalType": "uint32", "name": "_blockTimestampLast", "type": "uint32" }
-        ],
-        "payable": false,
-        "stateMutability": "view",
-        "type": "function"
-    }
-];
 exports.PANCAKE_V2_ROUTER_ABI = [
     'function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts)',
     'function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts)',
     'function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts)',
     'function getAmountsOut(uint amountIn, address[] memory path) public view returns (uint[] memory amounts)'
 ];
-exports.PANCAKE_V3_ROUTER_ABI = [
-    'function exactInputSingle(tuple(address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96)) external payable returns (uint256 amountOut)',
-    'function exactInput(tuple(bytes path, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum)) external payable returns (uint256 amountOut)',
-    'function exactOutputSingle(tuple(address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96)) external payable returns (uint256 amountIn)',
-    'function exactOutput(tuple(bytes path, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum)) external payable returns (uint256 amountIn)'
+exports.PancakeV3PoolABI = [
+    "function slot0() external view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)",
+    "function liquidity() external view returns (uint128)",
+    "function tickSpacing() external view returns (int24)",
+    "function factory() external view returns (address)",
+    "function token0() external view returns (address)",
+    "function token1() external view returns (address)",
+    "function fee() external view returns (uint24)",
+    "function ticks(int24 tick) external view returns (uint128 liquidityGross, int128 liquidityNet, int56 tickCumulativeOutside, uint160 secondsPerLiquidityOutsideX128, uint32 secondsOutside, bool initialized)",
+    "function tickBitmap(int16 wordPosition) external view returns (uint256)",
 ];

package/dist/common/constants.d.ts

@@ -18,9 +18,3 @@ export declare const EVENT_NAMES: {
     readonly QUOTE_TRIGGER: "quote_trigger";
     readonly WS_CONNECTION_FAILED: "ws_connection_failed";
 };
-export declare const EVENT_SIGNATURES: {
-    SWAP_RAW: string;
-    MINT: string;
-    BURN: string;
-};
-export declare const PancakeV3PoolABI: string[];

package/dist/common/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PancakeV3PoolABI = exports.EVENT_SIGNATURES = exports.EVENT_NAMES = exports.PANCAKE_UNIVERSAL_ROUTER_ADDRESS = exports.PANCAKE_PERMIT2_ADDRESS = exports.PANCAKE_SMART_ROUTER_ADDRESS = exports.PANCAKE_V3_ROUTER_ADDRESS = exports.PANCAKE_V3_QUOTER_ADDRESS = exports.PANCAKE_V2_ROUTER_ADDRESS = exports.Q96 = exports.NATIVE_BNB_ADDRESS = exports.WBNB_ADDRESS = exports.BSC_CHAIN_ID = void 0;
+exports.EVENT_NAMES = exports.PANCAKE_UNIVERSAL_ROUTER_ADDRESS = exports.PANCAKE_PERMIT2_ADDRESS = exports.PANCAKE_SMART_ROUTER_ADDRESS = exports.PANCAKE_V3_ROUTER_ADDRESS = exports.PANCAKE_V3_QUOTER_ADDRESS = exports.PANCAKE_V2_ROUTER_ADDRESS = exports.Q96 = exports.NATIVE_BNB_ADDRESS = exports.WBNB_ADDRESS = exports.BSC_CHAIN_ID = void 0;
 exports.BSC_CHAIN_ID = 56;
 exports.WBNB_ADDRESS = '0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c';
 exports.NATIVE_BNB_ADDRESS = '0x0000000000000000000000000000000000000000';
@@ -21,19 +21,3 @@ exports.EVENT_NAMES = {
     QUOTE_TRIGGER: 'quote_trigger',
     WS_CONNECTION_FAILED: 'ws_connection_failed',
 };
-exports.EVENT_SIGNATURES = {
-    SWAP_RAW: "Swap(address indexed sender, address indexed recipient, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick, uint128 protocolFeesToken0, uint128 protocolFeesToken1)",
-    MINT: "event Mint(address sender, address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1)",
-    BURN: "event Burn(address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1)"
-};
-exports.PancakeV3PoolABI = [
-    "function slot0() external view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)",
-    "function liquidity() external view returns (uint128)",
-    "function tickSpacing() external view returns (int24)",
-    "function factory() external view returns (address)",
-    "function token0() external view returns (address)",
-    "function token1() external view returns (address)",
-    "function fee() external view returns (uint24)",
-    "function ticks(int24 tick) external view returns (uint128 liquidityGross, int128 liquidityNet, int56 tickCumulativeOutside, uint160 secondsPerLiquidityOutsideX128, uint32 secondsOutside, bool initialized)",
-    "function tickBitmap(int16 wordPosition) external view returns (uint256)",
-];

package/dist/quote/abstract_dex_quote.d.ts

@@ -0,0 +1,59 @@
+import { AppConfig, DEX_ID, QuoteResultType, StandardPoolInfoType, QuoteDepthOutput } from '@clonegod/ttd-core';
+import { ChainOps } from './chain_ops';
+import { QuotePriceVerify, CheckSwapParams } from './verify/quote_price_verify';
+import { QuoteTrace } from './quote_trace';
+export interface PoolInitSummary {
+    protocol_type: string;
+    fee_bps: number;
+    tick_spacing?: number;
+    token0: string;
+    token1: string;
+    verifyContract?: string;
+}
+export interface QuoteBundle {
+    poolInfo: StandardPoolInfoType;
+    quote_amount_usd: number;
+    streamTimestamp: number;
+    quoteStartTime: number;
+    blockNumber: number;
+    txIndex?: number;
+    askQuote: QuoteResultType;
+    bidQuote: QuoteResultType;
+    txid: string;
+    source?: string;
+    depth?: QuoteDepthOutput;
+    priceMap?: Map<string, {
+        price: string;
+    } | undefined>;
+    trace?: QuoteTrace;
+}
+export declare abstract class AbstractDexQuote<C extends ChainOps = ChainOps> {
+    protected appConfig: AppConfig;
+    protected chain: C;
+    protected poolInfoMap: Map<string, StandardPoolInfoType>;
+    private poolLastQuoteTimeMap;
+    private lastPublished;
+    protected quotePriceVerify: QuotePriceVerify;
+    private readonly MIN_QUOTE_INTERVAL_MS;
+    constructor(appConfig: AppConfig, chain: C);
+    protected abstract readonly dexId: DEX_ID;
+    protected abstract readonly debouncedEventTypes: string[];
+    protected abstract loadPool(poolInfo: StandardPoolInfoType): Promise<PoolInitSummary>;
+    protected abstract quoteV1(poolInfo: StandardPoolInfoType, isBuy: boolean): Promise<QuoteResultType>;
+    protected abstract quoteV2(poolInfo: StandardPoolInfoType, isBuy: boolean): Promise<QuoteResultType>;
+    protected abstract refreshStateFromEvent(poolInfo: StandardPoolInfoType, eventData: any): void | Promise<void>;
+    protected abstract calculateDepth(poolInfo: StandardPoolInfoType, poolAddress: string, priceMap: Map<string, {
+        price: string;
+    } | undefined>): Promise<QuoteDepthOutput | undefined>;
+    protected abstract buildSwapVerify(poolInfo: StandardPoolInfoType, eventData: any): CheckSwapParams | null;
+    init(poolList: StandardPoolInfoType[]): Promise<void>;
+    protected beforeLoadPools(): Promise<void>;
+    private registerEventHandlers;
+    private assertValidBlockNumber;
+    private isStaleUpdate;
+    private handleBlockUpdateEvent;
+    private calculateQuote;
+    private calculateQuoteForPool;
+    protected publishQuote(result: QuoteBundle): void;
+    private do_quote_v3;
+}

package/dist/quote/abstract_dex_quote.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractDexQuote = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const quote_price_verify_1 = require("./verify/quote_price_verify");
+const price_feed_handler_1 = require("./price_feed_handler");
+const quote_amount_1 = require("./quote_amount");
+const quote_trace_1 = require("./quote_trace");
+class AbstractDexQuote {
+    constructor(appConfig, chain) {
+        this.poolInfoMap = new Map();
+        this.poolLastQuoteTimeMap = new Map();
+        this.lastPublished = new Map();
+        this.quotePriceVerify = new quote_price_verify_1.QuotePriceVerify();
+        this.MIN_QUOTE_INTERVAL_MS = Math.max(3000, parseInt(process.env.MIN_QUOTE_INTERVAL_MS || '10000', 10) || 10000);
+        this.appConfig = appConfig;
+        this.chain = chain;
+    }
+    async init(poolList) {
+        (0, ttd_core_1.log_info)(`初始化 ${this.dexId} Quote，共 ${poolList.length} 个池...`);
+        for (const poolInfo of poolList) {
+            if (!this.chain.isValidPoolAddress(poolInfo.pool_address)) {
+                (0, ttd_core_1.log_warn)(`跳过无效的池地址: ${poolInfo.pool_address}`, '');
+                continue;
+            }
+            this.poolInfoMap.set(poolInfo.pool_address, poolInfo);
+        }
+        await this.beforeLoadPools();
+        await Promise.all(Array.from(this.poolInfoMap.values()).map(async (p) => {
+            const summary = await this.loadPool(p);
+            if (summary.verifyContract)
+                await this.chain.assertContractDeployed(summary.verifyContract);
+            (0, ttd_core_1.log_info)(`[QUOTE INIT] ${p.pool_name} (${p.pool_address}) dex=${this.dexId}`, { ...summary });
+        }));
+        this.registerEventHandlers();
+        (0, ttd_core_1.log_info)(`${this.dexId} Quote 初始化完成，${this.poolInfoMap.size} 个有效池`);
+    }
+    async beforeLoadPools() { }
+    registerEventHandlers() {
+        this.chain.subscribeNewBlock((raw) => this.handleBlockUpdateEvent(raw));
+        this.chain.subscribePoolEvents(this.dexId, Array.from(this.poolInfoMap.values()), async (evt) => {
+            if (evt.type === 'subscribed')
+                return;
+            if (!evt.data) {
+                (0, ttd_core_1.log_warn)(`[${this.dexId}] pool event: no data`, evt);
+                return;
+            }
+            const { bundle, verifyLog } = await this.calculateQuote(evt);
+            if (bundle)
+                this.publishQuote(bundle);
+            if (verifyLog)
+                (0, ttd_core_1.log_info)(verifyLog);
+        });
+    }
+    assertValidBlockNumber(blockNumber, ctx) {
+        if (!Number.isInteger(blockNumber) || blockNumber <= 0) {
+            throw new Error(`[block-number] ${ctx}: 非法 blockNumber=${blockNumber}，每条数据源必须携带真实区块号`);
+        }
+    }
+    isStaleUpdate(poolAddr, block, txIndex) {
+        const last = this.lastPublished.get(poolAddr);
+        return !!last && (block < last.block || (block === last.block && txIndex <= last.txIndex));
+    }
+    async handleBlockUpdateEvent(eventData) {
+        const { blockNumber, recvBlockTime } = JSON.parse(eventData);
+        this.assertValidBlockNumber(blockNumber, `${this.dexId} block-event`);
+        for (const poolInfo of this.poolInfoMap.values()) {
+            const poolAddress = poolInfo.pool_address;
+            const now = Date.now();
+            const last = this.poolLastQuoteTimeMap.get(poolAddress) || 0;
+            if (now - last >= this.MIN_QUOTE_INTERVAL_MS) {
+                this.poolLastQuoteTimeMap.set(poolAddress, now);
+                const result = await this.calculateQuoteForPool(poolInfo, recvBlockTime, blockNumber);
+                if (result)
+                    this.publishQuote(result);
+            }
+        }
+    }
+    async calculateQuote(eventData) {
+        const poolInfo = this.poolInfoMap.get(eventData.pool_address);
+        if (!poolInfo)
+            return { bundle: null };
+        const eventType = eventData.type?.toLowerCase();
+        if (eventType === 'pricefeed')
+            return { bundle: this.do_quote_v3(poolInfo, eventData) };
+        let verifyLog;
+        if (eventType === 'swap') {
+            const v = this.buildSwapVerify(poolInfo, eventData);
+            if (v)
+                verifyLog = this.quotePriceVerify.checkSwap(v) || undefined;
+            if (!this.debouncedEventTypes.includes('swap'))
+                return { bundle: null, verifyLog };
+        }
+        const blockNumber = eventData.data?.blockNumber;
+        this.assertValidBlockNumber(blockNumber, `${this.dexId} ${poolInfo.pool_name} ${eventType}`);
+        await this.refreshStateFromEvent(poolInfo, eventData);
+        const txIndex = eventData.data?.transactionIndex;
+        if (Number.isInteger(txIndex) && this.isStaleUpdate(poolInfo.pool_address, blockNumber, txIndex))
+            return { bundle: null, verifyLog };
+        const bundle = await this.calculateQuoteForPool(poolInfo, eventData.event_time, blockNumber, eventData);
+        return { bundle, verifyLog };
+    }
+    async calculateQuoteForPool(poolInfo, streamTimestamp, blockNumber, eventData) {
+        const { pool_address } = poolInfo;
+        const eventDriven = !!eventData && this.debouncedEventTypes.includes(eventData.type?.toLowerCase());
+        const source = eventDriven ? `${eventData.provider_id || 'local'}:v2` : 'rpc:v1';
+        const trace = new quote_trace_1.QuoteTrace(poolInfo.pool_name, pool_address, blockNumber, source);
+        trace.mark('trigger');
+        let stage = 'compute';
+        try {
+            const quote_amount_usd = (0, quote_amount_1.getQuoteAmountUsd)(poolInfo);
+            const quoteStartTime = Date.now();
+            const txid = eventData ? (eventData.data?.transactionHash || 'block') : 'block';
+            const txIndex = eventData?.data?.transactionIndex;
+            let askQuote, bidQuote;
+            if (eventDriven) {
+                ;
+                [askQuote, bidQuote] = await Promise.all([this.quoteV2(poolInfo, true), this.quoteV2(poolInfo, false)]);
+            }
+            else {
+                ;
+                [askQuote, bidQuote] = await Promise.all([this.quoteV1(poolInfo, true), this.quoteV1(poolInfo, false)]);
+            }
+            trace.mark('compute');
+            const askN = Number(askQuote.price), bidN = Number(bidQuote.price);
+            if (askN > 0 && bidN > 0 && askN < bidN) {
+                throw new Error(`ask(${askN}) < bid(${bidN}) — 异常价差，丢弃该报价`);
+            }
+            this.poolLastQuoteTimeMap.set(pool_address, Date.now());
+            stage = 'depth';
+            const t0a = poolInfo.tokenA?.address, t1a = poolInfo.tokenB?.address;
+            const priceMap = (t0a && t1a) ? await this.chain.loadTokenPrices([t0a, t1a]) : new Map();
+            const depth = await this.calculateDepth(poolInfo, pool_address, priceMap);
+            trace.mark('depth');
+            trace.set('ask', askQuote.price);
+            trace.set('bid', bidQuote.price);
+            trace.set('tiers', depth?.ask?.tiers?.length ?? 0);
+            trace.set('quote_amount_usd', quote_amount_usd);
+            trace.set('txid', txid);
+            return { poolInfo, quote_amount_usd, streamTimestamp, quoteStartTime, blockNumber, txIndex, askQuote, bidQuote, txid, source, depth, priceMap, trace };
+        }
+        catch (error) {
+            trace.markError(stage, error instanceof Error ? error.message : String(error));
+            trace.flush();
+            return null;
+        }
+    }
+    publishQuote(result) {
+        const poolAddr = result.poolInfo.pool_address;
+        const isV2 = result.source?.endsWith(':v2');
+        let shouldPush = true;
+        if (result.source?.endsWith(':v1')) {
+            shouldPush = true;
+        }
+        else {
+            const incomingTx = result.txIndex;
+            if (!Number.isInteger(incomingTx)) {
+                throw new Error(`[publish] ${result.source} ${poolAddr}: 缺/非法 txIndex=${incomingTx}，事件源必须提供块内序号`);
+            }
+            const tx = incomingTx;
+            shouldPush = !this.isStaleUpdate(poolAddr, result.blockNumber, tx);
+            if (shouldPush)
+                this.lastPublished.set(poolAddr, { block: result.blockNumber, txIndex: tx });
+        }
+        if (shouldPush) {
+            const push = result.source?.includes(':v3') ? this.appConfig.env_args.use_pricefeed_for_orderbook : true;
+            (0, ttd_core_1.on_quote_response)({
+                appConfig: this.appConfig, poolInfo: result.poolInfo, quoteAmountUsd: result.quote_amount_usd,
+                streamTime: result.streamTimestamp, quoteStartTime: result.quoteStartTime, blockNumber: result.blockNumber,
+                quotes: [result.askQuote, result.bidQuote], txid: result.txid, pushPriceMessage: push,
+                source: result.source, depth: result.depth,
+            });
+        }
+        result.trace?.set('published', shouldPush);
+        result.trace?.mark('publish');
+        const candidateTiers = isV2 && result.depth ? {
+            ask_tiers: result.depth.ask.tiers.map(t => ({ pct: t.pct, price: t.price, amount: t.amount, amount_in: t.amount_in })),
+            bid_tiers: result.depth.bid.tiers.map(t => ({ pct: t.pct, price: t.price, amount: t.amount, amount_in: t.amount_in })),
+        } : {};
+        (0, ttd_core_1.report_quote_candidate)({
+            pool_address: poolAddr, pair: result.poolInfo.pair, dex_id: result.poolInfo.dex_id,
+            source: result.source || '', block_number: result.blockNumber,
+            ask_price: result.askQuote.price, bid_price: result.bidQuote.price, ...candidateTiers,
+        });
+        const quoteId = result.txid?.slice(0, 10) || `blk:${result.blockNumber}`;
+        const tiersArg = isV2 ? { askTiers: result.depth?.ask?.tiers, bidTiers: result.depth?.bid?.tiers } : undefined;
+        const t0a = result.poolInfo.tokenA?.address, t1a = result.poolInfo.tokenB?.address;
+        const p0 = t0a ? Number(result.priceMap?.get(t0a.toLowerCase())?.price) || 0 : 0;
+        const p1 = t1a ? Number(result.priceMap?.get(t1a.toLowerCase())?.price) || 0 : 0;
+        this.quotePriceVerify.cacheQuote(poolAddr, quoteId, result.source || '', Number(result.askQuote.price), Number(result.bidQuote.price), result.blockNumber, result.quote_amount_usd, p0, p1, tiersArg);
+        result.trace?.mark('verify');
+        result.trace?.flush();
+    }
+    do_quote_v3(poolInfo, eventData) {
+        this.assertValidBlockNumber(eventData.data?.blockNumber, `${this.dexId} ${poolInfo.pool_name} pricefeed`);
+        const result = (0, price_feed_handler_1.buildQuoteFromPriceFeed)(poolInfo, eventData.data);
+        if (!result)
+            return null;
+        const source = `${eventData.provider_id || 'PriceFeed'}:v3`;
+        const trace = new quote_trace_1.QuoteTrace(poolInfo.pool_name, poolInfo.pool_address, eventData.data.blockNumber, source);
+        trace.mark('trigger');
+        trace.mark('compute');
+        trace.set('ask', result.askQuote.price);
+        trace.set('bid', result.bidQuote.price);
+        return {
+            poolInfo, quote_amount_usd: poolInfo.quote_amount_usd, streamTimestamp: eventData.event_time,
+            quoteStartTime: Date.now(), blockNumber: eventData.data.blockNumber,
+            txIndex: eventData.data?.transactionIndex,
+            askQuote: result.askQuote, bidQuote: result.bidQuote,
+            txid: `PriceFeed - ${eventData.provider_id}`, source, trace,
+        };
+    }
+}
+exports.AbstractDexQuote = AbstractDexQuote;

package/dist/quote/chain_ops.d.ts

@@ -0,0 +1,11 @@
+import { CHAIN_ID, DEX_ID, StandardPoolInfoType } from '@clonegod/ttd-core';
+export interface ChainOps {
+    readonly chainId: CHAIN_ID;
+    isValidPoolAddress(addr: string): boolean;
+    assertContractDeployed(contractAddress: string): Promise<void>;
+    loadTokenPrices(addresses: string[]): Promise<Map<string, {
+        price: string;
+    } | undefined>>;
+    subscribeNewBlock(handler: (raw: string) => void): void;
+    subscribePoolEvents(dexId: DEX_ID, pools: StandardPoolInfoType[], handler: (evt: any) => void): void;
+}

package/dist/quote/chain_ops.js

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

package/dist/quote/depth/index.js

@@ -69,31 +69,6 @@ function grossUpFee(amountInNet, feeRateBps) {
     return { amountInGross, feeAmount };
 }
 const _tickLiquidityLastBuild = new Map();
-const _tierInvariantLastWarn = new Map();
-function assertTierInvariant(poolLabel, side, tiers) {
-    if (!tiers || tiers.length === 0)
-        return;
-    const TOL_REL = 0.0001;
-    for (const t of tiers) {
-        if (!(t.price > 0) || !(t.amount > 0) || !(t.amount_in > 0))
-            continue;
-        const expected = side === 'ASK' ? t.amount_in / t.amount : t.amount / t.amount_in;
-        if (!(expected > 0))
-            continue;
-        const relDiff = Math.abs(t.price - expected) / expected;
-        if (relDiff > TOL_REL) {
-            const key = `${poolLabel}_${side}_${t.pct}`;
-            const now = Date.now();
-            if ((now - (_tierInvariantLastWarn.get(key) || 0)) < 60000)
-                return;
-            _tierInvariantLastWarn.set(key, now);
-            (0, ttd_core_1.log_warn)(`[tier-invariant] ${poolLabel} ${side} pct=${t.pct} price=${t.price.toFixed(10)} ` +
-                `≠ expected ${expected.toFixed(10)} (relDiff=${(relDiff * 10000).toFixed(2)}bps) — ` +
-                `tier.price MUST be effective avg price including fee`);
-            return;
-        }
-    }
-}
 function assembleEntry(tiers) {
     const defaultTier = tiers.find(t => t.pct === ttd_core_2.DEFAULT_TIER_PCT) ?? tiers[0];
     return {
@@ -179,8 +154,6 @@ function buildClmmDepth(input) {
                 tick_move: bidTickMove,
             });
         }
-        assertTierInvariant(poolInfo.pool_name || poolAddress, 'ASK', askTiers);
-        assertTierInvariant(poolInfo.pool_name || poolAddress, 'BID', bidTiers);
         const depth = {
             mid_price: midPrice,
             fee_rate_bps: feeRateBps,
@@ -281,8 +254,6 @@ function buildAmmDepth(input) {
                 fee_usd: bidGross.feeAmount * basePriceUsd,
             });
         }
-        assertTierInvariant(poolInfo.pool_name || 'amm-pool', 'ASK', askTiers);
-        assertTierInvariant(poolInfo.pool_name || 'amm-pool', 'BID', bidTiers);
         return {
             mid_price: midPrice,
             fee_rate_bps: feeRateBps,

package/dist/quote/evm_chain_ops.d.ts

@@ -0,0 +1,30 @@
+import { ethers } from 'ethers';
+import { CHAIN_ID, DEX_ID, StandardPoolInfoType } from '@clonegod/ttd-core';
+import { ChainOps } from './chain_ops';
+type TokenPriceMap = Map<string, {
+    price: string;
+} | undefined>;
+interface NewBlockSubscriber {
+    subscribe_new_block(chainId: CHAIN_ID, handler: (raw: string) => any): void;
+}
+export interface EvmChainOpsArgs {
+    provider: ethers.providers.Provider;
+    chainId: CHAIN_ID;
+    loadTokenPrices: (addresses: string[]) => Promise<TokenPriceMap>;
+    streamQuoteWsHost: string;
+    newBlockSubscriber: NewBlockSubscriber;
+}
+export declare class EvmChainOps implements ChainOps {
+    readonly provider: ethers.providers.Provider;
+    readonly chainId: CHAIN_ID;
+    private readonly priceFn;
+    private readonly streamQuoteWsHost;
+    private readonly newBlockSubscriber;
+    constructor(args: EvmChainOpsArgs);
+    isValidPoolAddress(addr: string): boolean;
+    assertContractDeployed(contractAddress: string): Promise<void>;
+    loadTokenPrices(addresses: string[]): Promise<TokenPriceMap>;
+    subscribeNewBlock(handler: (raw: string) => void): void;
+    subscribePoolEvents(dexId: DEX_ID, pools: StandardPoolInfoType[], handler: (evt: any) => void): void;
+}
+export {};

package/dist/quote/evm_chain_ops.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvmChainOps = void 0;
+const ethers_1 = require("ethers");
+const ttd_core_1 = require("@clonegod/ttd-core");
+class EvmChainOps {
+    constructor(args) {
+        this.provider = args.provider;
+        this.chainId = args.chainId;
+        this.priceFn = args.loadTokenPrices;
+        this.streamQuoteWsHost = args.streamQuoteWsHost;
+        this.newBlockSubscriber = args.newBlockSubscriber;
+    }
+    isValidPoolAddress(addr) {
+        return ethers_1.ethers.utils.isAddress(addr) || /^0x[0-9a-fA-F]{64}$/.test(addr);
+    }
+    async assertContractDeployed(contractAddress) {
+        if (!contractAddress)
+            return;
+        const code = await this.provider.getCode(contractAddress);
+        if (!code || code === '0x') {
+            throw new Error(`[contract-deployed] EVM 合约无 code: ${contractAddress}（地址写错 / 抄了别的链?）`);
+        }
+    }
+    loadTokenPrices(addresses) {
+        return this.priceFn(addresses);
+    }
+    subscribeNewBlock(handler) {
+        this.newBlockSubscriber.subscribe_new_block(this.chainId, handler);
+    }
+    subscribePoolEvents(dexId, pools, handler) {
+        const ws_url = `ws://${this.streamQuoteWsHost}:${ttd_core_1.SERVICE_PORT.STREAM_QUOTE_WS}`;
+        const ws_client = new ttd_core_1.WebSocketClient(ws_url);
+        ws_client.onOpen(() => {
+            pools.forEach((poolInfo) => {
+                ws_client.send(JSON.stringify({
+                    dex_id: dexId,
+                    pool_name: poolInfo.pool_name,
+                    pair: poolInfo.pair,
+                    pool_address: poolInfo.pool_address,
+                }));
+            });
+            (0, ttd_core_1.log_info)(`已订阅 stream-quote 池事件, dex=${dexId}, pools: ${pools.length}`);
+        });
+        ws_client.onMessage((evt) => handler(evt));
+        ws_client.connect();
+    }
+}
+exports.EvmChainOps = EvmChainOps;

package/dist/quote/index.d.ts

@@ -6,3 +6,7 @@ export * from './verify';
 export * from './price_feed_handler';
 export * from './quote_amount';
 export * from './preload_token_prices';
+export * from './abstract_dex_quote';
+export * from './chain_ops';
+export * from './evm_chain_ops';
+export * from './quote_trace';

package/dist/quote/index.js

@@ -22,3 +22,7 @@ __exportStar(require("./verify"), exports);
 __exportStar(require("./price_feed_handler"), exports);
 __exportStar(require("./quote_amount"), exports);
 __exportStar(require("./preload_token_prices"), exports);
+__exportStar(require("./abstract_dex_quote"), exports);
+__exportStar(require("./chain_ops"), exports);
+__exportStar(require("./evm_chain_ops"), exports);
+__exportStar(require("./quote_trace"), exports);

package/dist/quote/quote_trace.d.ts

@@ -0,0 +1,16 @@
+export declare class QuoteTrace {
+    readonly poolName: string;
+    readonly poolAddress: string;
+    blockNumber: number;
+    source: string;
+    private startTime;
+    private marks;
+    private data;
+    private error;
+    constructor(poolName: string, poolAddress: string, blockNumber?: number, source?: string);
+    mark(name: string): void;
+    set(key: string, value: any): void;
+    markError(stage: string, message: string): void;
+    private buildTimeline;
+    flush(): void;
+}

package/dist/quote/quote_trace.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuoteTrace = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const logger = (0, ttd_core_1.createLogger)(__filename);
+class QuoteTrace {
+    constructor(poolName, poolAddress, blockNumber = 0, source = '') {
+        this.poolName = poolName;
+        this.poolAddress = poolAddress;
+        this.blockNumber = blockNumber;
+        this.source = source;
+        this.startTime = Date.now();
+        this.marks = [];
+        this.data = {};
+        this.error = null;
+    }
+    mark(name) {
+        this.marks.push({ name, elapsed: Date.now() - this.startTime });
+    }
+    set(key, value) { this.data[key] = value; }
+    markError(stage, message) { this.error = { stage, message }; }
+    buildTimeline() {
+        if (this.marks.length === 0)
+            return '(no marks)';
+        let prev = 0;
+        const parts = this.marks.map(m => { const d = m.elapsed - prev; prev = m.elapsed; return `${m.name}(${d}ms)`; });
+        return `${parts.join(' -> ')} = ${this.marks[this.marks.length - 1].elapsed}ms`;
+    }
+    flush() {
+        const timeline = this.buildTimeline();
+        if (this.error) {
+            logger.error(`[QUOTE FAILED] ${this.poolName} | stage=${this.error.stage} | source=${this.source} | ${this.error.message}`, new Error(this.error.message));
+            logger.info(`[QUOTE FAILED detail] ${this.poolName}`, { timeline, error_stage: this.error.stage, source: this.source, ...this.data });
+        }
+        else {
+            logger.debug(`[QUOTE OK] ${this.poolName} blk=${this.blockNumber} source=${this.source}`, { timeline, ...this.data });
+        }
+    }
+}
+exports.QuoteTrace = QuoteTrace;

package/dist/quote/verify/quote_price_verify.d.ts

@@ -24,7 +24,7 @@ export declare class QuotePriceVerify {
         askTiers?: QuoteTier[];
         bidTiers?: QuoteTier[];
     }): void;
-    checkSwap(params: CheckSwapParams): void;
+    checkSwap(params: CheckSwapParams): string | void;
     private deriveSwapDirection;
     private compareAndLog;
 }

package/dist/quote/verify/quote_price_verify.js

@@ -7,26 +7,26 @@ function pickMatchingTier(tiers, actualAmountIn) {
     if (!tiers || tiers.length === 0)
         return null;
     if (tiers.length === 1)
-        return { tier: tiers[0], mode: 'single_tier' };
+        return { tier: tiers[0], mode: 'single_tier', lo_pct: tiers[0].pct, hi_pct: tiers[0].pct };
     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' };
+        return { tier: sorted[0], mode: 'extrapolated_low', lo_pct: null, hi_pct: sorted[0].pct };
     }
     if (actualAmountIn > top.amount_in) {
-        return { tier: top, mode: 'extrapolated_high' };
+        return { tier: top, mode: 'extrapolated_high', lo_pct: top.pct, hi_pct: null };
     }
     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' };
+                return { tier: lower, mode: 'exact', lo_pct: lower.pct, hi_pct: lower.pct };
             if (actualAmountIn === upper.amount_in)
-                return { tier: upper, mode: 'exact' };
+                return { tier: upper, mode: 'exact', lo_pct: upper.pct, hi_pct: upper.pct };
             const span = upper.amount_in - lower.amount_in;
             if (span <= 0)
-                return { tier: lower, mode: 'exact' };
+                return { tier: lower, mode: 'exact', lo_pct: lower.pct, hi_pct: lower.pct };
             const ratio = (actualAmountIn - lower.amount_in) / span;
             const lerp = (a, b) => a + ratio * (b - a);
             return {
@@ -40,10 +40,12 @@ function pickMatchingTier(tiers, actualAmountIn) {
                     fee_usd: lerp(lower.fee_usd, upper.fee_usd),
                 },
                 mode: 'interpolated',
+                lo_pct: lower.pct,
+                hi_pct: upper.pct,
             };
         }
     }
-    return { tier: top, mode: 'extrapolated_high' };
+    return { tier: top, mode: 'extrapolated_high', lo_pct: top.pct, hi_pct: null };
 }
 class QuotePriceVerify {
     constructor() {
@@ -111,6 +113,8 @@ class QuotePriceVerify {
                     matched_pct: parseFloat(match.tier.pct.toFixed(4)),
                     mode: match.mode,
                     tier_amount_in: match.tier.amount_in,
+                    lo_pct: match.lo_pct,
+                    hi_pct: match.hi_pct,
                 };
             }
             else {
@@ -131,6 +135,7 @@ class QuotePriceVerify {
             sources[r.source] = {
                 ask: r.cached.askPrice,
                 bid: r.cached.bidPrice,
+                matched_ref_price: r.refPrice,
                 diff_bps: parseFloat(r.diff_bps.toFixed(1)),
                 quote_block: r.cached.referenceBlock,
                 ...(r.tierInfo && {
@@ -140,7 +145,7 @@ class QuotePriceVerify {
                 }),
             };
         }
-        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);
+        return 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;
@@ -202,7 +207,6 @@ class QuotePriceVerify {
         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,
@@ -230,11 +234,14 @@ class QuotePriceVerify {
                     matched_tier_pct: primaryTierInfo.matched_pct,
                     matched_tier_mode: primaryTierInfo.mode,
                     matched_tier_amount_in: primaryTierInfo.tier_amount_in,
+                    matched_tier_lo_pct: primaryTierInfo.lo_pct,
+                    matched_tier_hi_pct: primaryTierInfo.hi_pct,
                 }),
             });
         }
         catch (_) {
         }
+        return msg;
     }
 }
 exports.QuotePriceVerify = QuotePriceVerify;

package/dist/trade/abstract_dex_trade.js

@@ -64,8 +64,8 @@ function buildTradeConfig(envArgs) {
     return {
         vaultAddress: vaultWallet.public_key,
         executorIds: {
-            pancake: ethers_compat_1.ethersCompat.id(envArgs.pancake_executor_id),
-            uniswap: ethers_compat_1.ethersCompat.id(envArgs.uniswap_executor_id),
+            pancake: ethers_compat_1.ethersCompat.id(envArgs.pancake_executor_id.toUpperCase()),
+            uniswap: ethers_compat_1.ethersCompat.id(envArgs.uniswap_executor_id.toUpperCase()),
         },
     };
 }
@@ -93,11 +93,11 @@ class AbstractDexTrade extends ttd_core_1.AbastrcatTrade {
             gasOptions: {
                 gasLimit: env.gas_limit,
                 defaultGasPriceGwei: env.gas_price_gwei,
-                maxGasPriceGwei: 10,
-                maxFeePerGasGwei: 10,
-                maxPriorityFeePerGasGwei: 3,
+                maxGasPriceGwei: env.gas_max_price_gwei,
+                maxFeePerGasGwei: env.gas_max_fee_per_gas_gwei,
+                maxPriorityFeePerGasGwei: env.gas_max_priority_fee_gwei,
                 defaultTipAmountGwei: env.tip_amount_gwei,
-                maxTipAmountGwei: 500000,
+                maxTipAmountGwei: env.gas_max_tip_amount_gwei,
             }
         };
         this.tradeConfig = buildTradeConfig(env);

package/dist/trade/caller_manager.js

@@ -155,10 +155,13 @@ class CallerManager {
     async readNonce(callerAddr) {
         const nonceKey = this.getNonceRedisKey();
         const nonceStr = await this.redis.hget(nonceKey, callerAddr);
-        if (nonceStr === null || nonceStr === undefined) {
-            throw new Error(`Caller ${callerAddr} nonce not found in Redis, stream-trade may not be running`);
+        if (nonceStr !== null && nonceStr !== undefined) {
+            return parseInt(nonceStr, 10);
         }
-        return parseInt(nonceStr, 10);
+        const chainNonce = await this.config.provider.getTransactionCount(callerAddr, 'pending');
+        await this.setNonce(callerAddr, chainNonce);
+        logger.warn(`readNonce: ${callerAddr} 不在 Redis，已回链自愈 nonce=${chainNonce}（新 caller / 未成交 / TTL 过期）`);
+        return chainNonce;
     }
     async confirmNonce(address, confirmedNonce) {
         const current = await this.getNonce(address);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-bsc-common",
-  "version": "3.1.77",
+  "version": "3.1.79",
   "description": "BSC common library",
   "license": "UNLICENSED",
   "main": "dist/index.js",
@@ -14,8 +14,8 @@
     "push": "npm run build && npm publish"
   },
   "dependencies": {
-    "@clonegod/ttd-core": "3.1.79",
-    "axios": "1.15.0",
+    "@clonegod/ttd-core": "3.1.82",
+    "axios": "1.17.0",
     "dotenv": "^16.4.7",
     "ethers": "^5.8.0",
     "secp256k1": "^5.0.1"