@clonegod/ttd-sol-common 2.0.68 → 2.0.70

package/dist/quote/depth/amm_depth_calculator.d.ts

@@ -0,0 +1,19 @@
+export interface AmmDepthInput {
+    reserve0: string;
+    reserve1: string;
+    targetBps: number;
+    isBuy: boolean;
+    baseIsToken0: boolean;
+    token0Decimals: number;
+    token1Decimals: number;
+}
+export interface AmmDepthResult {
+    amountOutWei: bigint;
+    amountOut: number;
+    outputDecimals: number;
+    amountInWei: bigint;
+    amountIn: number;
+    inputDecimals: number;
+    targetPrice: number;
+}
+export declare function calculateAmmDepth(input: AmmDepthInput): AmmDepthResult;

package/dist/quote/depth/amm_depth_calculator.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateAmmDepth = calculateAmmDepth;
+const clmm_depth_calculator_1 = require("./clmm_depth_calculator");
+function calculateAmmDepth(input) {
+    const { targetBps, isBuy, baseIsToken0, token0Decimals, token1Decimals } = input;
+    const R0 = BigInt(input.reserve0);
+    const R1 = BigInt(input.reserve1);
+    if (R0 === 0n || R1 === 0n) {
+        return { amountOutWei: 0n, amountOut: 0, outputDecimals: 0, amountInWei: 0n, amountIn: 0, inputDecimals: 0, targetPrice: 0 };
+    }
+    const k = R0 * R1;
+    const bps = BigInt(targetBps);
+    const PRECISION = 10n ** 18n;
+    let amountOutWei;
+    let amountInWei;
+    let outputDecimals;
+    let inputDecimals;
+    if (isBuy) {
+        const [baseReserve, quoteReserve] = baseIsToken0 ? [R0, R1] : [R1, R0];
+        outputDecimals = baseIsToken0 ? token0Decimals : token1Decimals;
+        inputDecimals = baseIsToken0 ? token1Decimals : token0Decimals;
+        const baseReserveNew = baseReserve * (0, clmm_depth_calculator_1.bigIntSqrt)(10000n * PRECISION) / (0, clmm_depth_calculator_1.bigIntSqrt)((10000n + bps) * PRECISION);
+        const quoteReserveNew = quoteReserve * (0, clmm_depth_calculator_1.bigIntSqrt)((10000n + bps) * PRECISION) / (0, clmm_depth_calculator_1.bigIntSqrt)(10000n * PRECISION);
+        amountOutWei = baseReserve - baseReserveNew;
+        amountInWei = quoteReserveNew - quoteReserve;
+    }
+    else {
+        const [baseReserve, quoteReserve] = baseIsToken0 ? [R0, R1] : [R1, R0];
+        outputDecimals = baseIsToken0 ? token1Decimals : token0Decimals;
+        inputDecimals = baseIsToken0 ? token0Decimals : token1Decimals;
+        if (bps >= 10000n) {
+            amountOutWei = quoteReserve;
+            amountInWei = baseReserve;
+        }
+        else {
+            const quoteReserveNew = quoteReserve * (0, clmm_depth_calculator_1.bigIntSqrt)((10000n - bps) * PRECISION) / (0, clmm_depth_calculator_1.bigIntSqrt)(10000n * PRECISION);
+            const baseReserveNew = baseReserve * (0, clmm_depth_calculator_1.bigIntSqrt)(10000n * PRECISION) / (0, clmm_depth_calculator_1.bigIntSqrt)((10000n - bps) * PRECISION);
+            amountOutWei = quoteReserve - quoteReserveNew;
+            amountInWei = baseReserveNew - baseReserve;
+        }
+    }
+    const amountOut = Number(amountOutWei) / Math.pow(10, outputDecimals);
+    const amountIn = Number(amountInWei) / Math.pow(10, inputDecimals);
+    const baseDec = baseIsToken0 ? token0Decimals : token1Decimals;
+    const quoteDec = baseIsToken0 ? token1Decimals : token0Decimals;
+    const baseReserveUi = Number(baseIsToken0 ? R0 : R1) / Math.pow(10, baseDec);
+    const quoteReserveUi = Number(baseIsToken0 ? R1 : R0) / Math.pow(10, quoteDec);
+    const midPrice = quoteReserveUi / baseReserveUi;
+    const bpsNum = Number(targetBps);
+    const targetPrice = isBuy
+        ? midPrice * (10000 + bpsNum) / 10000
+        : midPrice * (10000 - bpsNum) / 10000;
+    return { amountOutWei, amountOut, outputDecimals, amountInWei, amountIn, inputDecimals, targetPrice };
+}

package/dist/quote/depth/index.d.ts

@@ -1,8 +1,15 @@
 import { StandardPoolInfoType } from '@clonegod/ttd-core/dist';
-import { QuoteDepthOutput } from '@clonegod/ttd-core/dist';
+import { QuoteTier, QuoteEntry, QuoteDepthOutput } from '@clonegod/ttd-core/dist';
 import { DepthTick } from './clmm_depth_calculator';
 export { calculateClmmDepth, priceFromSqrtX64, computeTargetSqrtX64, bigIntSqrt, swapExactInClmm } from './clmm_depth_calculator';
 export type { DepthTick, ClmmDepthInput, DepthResult, SwapExactInInput, SwapExactInResult } from './clmm_depth_calculator';
+export { calculateAmmDepth } from './amm_depth_calculator';
+export type { AmmDepthInput, AmmDepthResult } from './amm_depth_calculator';
+export declare function grossUpFee(amountInNet: number, feeRateBps: number): {
+    amountInGross: number;
+    feeAmount: number;
+};
+export declare function assembleEntry(tiers: QuoteTier[]): QuoteEntry;
 export interface BuildClmmDepthInput {
     poolInfo: StandardPoolInfoType;
     poolAddress: string;
@@ -18,3 +25,13 @@ export interface BuildClmmDepthInput {
     feeRateBps: number;
 }
 export declare function buildClmmDepth(input: BuildClmmDepthInput): QuoteDepthOutput | undefined;
+export interface BuildAmmDepthInput {
+    poolInfo: StandardPoolInfoType;
+    reserve0: string;
+    reserve1: string;
+    baseIsToken0: boolean;
+    basePriceUsd: number;
+    quotePriceUsd: number;
+    feeRateBps: number;
+}
+export declare function buildAmmDepth(input: BuildAmmDepthInput): QuoteDepthOutput | undefined;

package/dist/quote/depth/index.js

@@ -1,17 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.swapExactInClmm = exports.bigIntSqrt = exports.computeTargetSqrtX64 = exports.priceFromSqrtX64 = exports.calculateClmmDepth = void 0;
+exports.calculateAmmDepth = exports.swapExactInClmm = exports.bigIntSqrt = exports.computeTargetSqrtX64 = exports.priceFromSqrtX64 = exports.calculateClmmDepth = void 0;
+exports.grossUpFee = grossUpFee;
+exports.assembleEntry = assembleEntry;
 exports.buildClmmDepth = buildClmmDepth;
+exports.buildAmmDepth = buildAmmDepth;
 const dist_1 = require("@clonegod/ttd-core/dist");
 const dist_2 = require("@clonegod/ttd-core/dist");
 const trade_direction_1 = require("../../utils/trade_direction");
 const clmm_depth_calculator_1 = require("./clmm_depth_calculator");
+const amm_depth_calculator_1 = require("./amm_depth_calculator");
 var clmm_depth_calculator_2 = require("./clmm_depth_calculator");
 Object.defineProperty(exports, "calculateClmmDepth", { enumerable: true, get: function () { return clmm_depth_calculator_2.calculateClmmDepth; } });
 Object.defineProperty(exports, "priceFromSqrtX64", { enumerable: true, get: function () { return clmm_depth_calculator_2.priceFromSqrtX64; } });
 Object.defineProperty(exports, "computeTargetSqrtX64", { enumerable: true, get: function () { return clmm_depth_calculator_2.computeTargetSqrtX64; } });
 Object.defineProperty(exports, "bigIntSqrt", { enumerable: true, get: function () { return clmm_depth_calculator_2.bigIntSqrt; } });
 Object.defineProperty(exports, "swapExactInClmm", { enumerable: true, get: function () { return clmm_depth_calculator_2.swapExactInClmm; } });
+var amm_depth_calculator_2 = require("./amm_depth_calculator");
+Object.defineProperty(exports, "calculateAmmDepth", { enumerable: true, get: function () { return amm_depth_calculator_2.calculateAmmDepth; } });
 let _depthPctLogged = false;
 function logDepthLevelsOnce() {
     if (_depthPctLogged)
@@ -98,3 +104,61 @@ function buildClmmDepth(input) {
         return undefined;
     }
 }
+function buildAmmDepth(input) {
+    logDepthLevelsOnce();
+    const pctLevels = (0, dist_2.getDepthPricePctLevels)();
+    if (pctLevels.length === 0)
+        return undefined;
+    const { poolInfo, reserve0, reserve1, baseIsToken0, basePriceUsd, quotePriceUsd, feeRateBps } = input;
+    if (feeRateBps == null || feeRateBps < 0) {
+        (0, dist_1.log_debug)(`[Depth] ${poolInfo.pool_name} AMM: invalid feeRateBps=${feeRateBps}, skip`, '');
+        return undefined;
+    }
+    try {
+        const dir = (0, trade_direction_1.resolveTradeDirection)(poolInfo, true);
+        const baseToken = dir.baseToken;
+        const quoteToken = dir.quoteToken;
+        const baseReserveUi = Number(BigInt(baseIsToken0 ? reserve0 : reserve1)) / Math.pow(10, baseToken.decimals);
+        const quoteReserveUi = Number(BigInt(baseIsToken0 ? reserve1 : reserve0)) / Math.pow(10, quoteToken.decimals);
+        const midPrice = quoteReserveUi / baseReserveUi;
+        const askTiers = [];
+        const bidTiers = [];
+        for (const pct of pctLevels) {
+            const bps = Math.round(pct * 100);
+            const askResult = (0, amm_depth_calculator_1.calculateAmmDepth)({
+                reserve0, reserve1, targetBps: bps, isBuy: true, baseIsToken0,
+                token0Decimals: baseIsToken0 ? baseToken.decimals : quoteToken.decimals,
+                token1Decimals: baseIsToken0 ? quoteToken.decimals : baseToken.decimals,
+            });
+            const bidResult = (0, amm_depth_calculator_1.calculateAmmDepth)({
+                reserve0, reserve1, targetBps: bps, isBuy: false, baseIsToken0,
+                token0Decimals: baseIsToken0 ? baseToken.decimals : quoteToken.decimals,
+                token1Decimals: baseIsToken0 ? quoteToken.decimals : baseToken.decimals,
+            });
+            const askGross = grossUpFee(askResult.amountIn, feeRateBps);
+            const bidGross = grossUpFee(bidResult.amountIn, feeRateBps);
+            const askEffPrice = askResult.amountOut > 0 ? askGross.amountInGross / askResult.amountOut : askResult.targetPrice;
+            const bidEffPrice = bidGross.amountInGross > 0 ? bidResult.amountOut / bidGross.amountInGross : bidResult.targetPrice;
+            askTiers.push({
+                pct, price: askEffPrice, amount: askResult.amountOut,
+                amount_in: askGross.amountInGross, amount_in_usd: askGross.amountInGross * quotePriceUsd,
+                fee: askGross.feeAmount, fee_usd: askGross.feeAmount * quotePriceUsd,
+            });
+            bidTiers.push({
+                pct, price: bidEffPrice, amount: bidResult.amountOut,
+                amount_in: bidGross.amountInGross, amount_in_usd: bidGross.amountInGross * basePriceUsd,
+                fee: bidGross.feeAmount, fee_usd: bidGross.feeAmount * basePriceUsd,
+            });
+        }
+        return {
+            mid_price: midPrice,
+            fee_rate_bps: feeRateBps,
+            ask: assembleEntry(askTiers),
+            bid: assembleEntry(bidTiers),
+        };
+    }
+    catch (error) {
+        (0, dist_1.log_debug)(`[Depth] ${poolInfo.pool_name} AMM depth failed: ${error.message}`, '');
+        return undefined;
+    }
+}

package/dist/trade/index.d.ts

@@ -2,5 +2,4 @@ export * from './tx_result_check';
 export * from './tx_result_parse';
 export * from './tx_builder';
 export * from './send';
-export * from './jito_tip_wallets';
 export * from './sol_gas_cache';

package/dist/trade/index.js

@@ -18,5 +18,4 @@ __exportStar(require("./tx_result_check"), exports);
 __exportStar(require("./tx_result_parse"), exports);
 __exportStar(require("./tx_builder"), exports);
 __exportStar(require("./send"), exports);
-__exportStar(require("./jito_tip_wallets"), exports);
 __exportStar(require("./sol_gas_cache"), exports);

package/dist/trade/send/send_tx.d.ts

@@ -3,5 +3,4 @@ import { TradeContext } from '@clonegod/ttd-core/dist';
 export declare class TransactionSender {
     constructor();
     sendTransaction(context: TradeContext, mainTx: Transaction | VersionedTransaction, swqos_only?: boolean): Promise<string>;
-    sendBundle(context: TradeContext, mainTx: Transaction | VersionedTransaction, tipTx: Transaction | VersionedTransaction, use_multi_ips?: boolean): Promise<string>;
 }

package/dist/trade/send/send_tx.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionSender = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const helius_1 = require("./helius");
-const jito_1 = require("./jito");
 const common_1 = require("../../common");
 const sol_gas_cache_1 = require("../sol_gas_cache");
 class TransactionSender {
@@ -15,18 +14,6 @@ class TransactionSender {
         const singedTxBase64 = serializeTransactionBase64(mainTx);
         return await (0, helius_1.sendTxWithHelius)(singedTxBase64, swqos_only);
     }
-    async sendBundle(context, mainTx, tipTx, use_multi_ips = false) {
-        const mainTxHash = (0, common_1.getSignature)(mainTx);
-        set_transaciton_gas_cost(mainTxHash, context);
-        const mainTxBase64 = serializeTransactionBase64(mainTx);
-        const tipTxBase64 = serializeTransactionBase64(tipTx);
-        if (use_multi_ips) {
-            return await (0, jito_1.sendBundleWithJitoMultiIps)(mainTxHash, mainTxBase64, tipTxBase64);
-        }
-        else {
-            return await (0, jito_1.sendBundleWithJito)(mainTxBase64, tipTxBase64);
-        }
-    }
 }
 exports.TransactionSender = TransactionSender;
 function serializeTransactionBase64(tx) {

package/dist/trade/tx_builder.d.ts

@@ -1,14 +1,12 @@
 import { TradeContext } from "@clonegod/ttd-core/dist";
 import { Connection, Keypair, Transaction, TransactionInstruction } from "@solana/web3.js";
 import { SolanaTradeAppConfig } from "../appconfig/SolanaTradeAppConfig";
-import { JitoTipWalletManager } from "./jito_tip_wallets";
 export declare class SolTransactionBuilder {
     appConfig: SolanaTradeAppConfig;
     connection: Connection;
     keypair: Keypair;
     recentBlockhash: string;
     recentBlockheight: number;
-    jitoTipWalletManager: JitoTipWalletManager;
     constructor(appConfig: SolanaTradeAppConfig);
     init(): Promise<void>;
     private handleBlockUpdateEvent;
@@ -16,5 +14,4 @@ export declare class SolTransactionBuilder {
     private createComputeUnitLimitWithJitoDontFront;
     private getPostInstructions;
     buildTransactionForSwap(context: TradeContext, swapInstructions: TransactionInstruction[]): Transaction;
-    buildTransactionForTipJito(context: TradeContext): Transaction;
 }

package/dist/trade/tx_builder.js

@@ -5,8 +5,6 @@ const dist_1 = require("@clonegod/ttd-core/dist");
 const web3_js_1 = require("@solana/web3.js");
 const common_1 = require("../common");
 const helius_1 = require("./send/helius");
-const jito_1 = require("./send/jito");
-const jito_tip_wallets_1 = require("./jito_tip_wallets");
 const jitodontfrontAccounts = [
     'jitodontfront111111111111111111111111111111',
     'jitodontfront111111111111111111111111111123',
@@ -52,7 +50,6 @@ class SolTransactionBuilder {
         this.appConfig = appConfig;
         this.connection = appConfig.connection;
         this.keypair = appConfig.keypair;
-        this.jitoTipWalletManager = new jito_tip_wallets_1.JitoTipWalletManager();
         this.init();
     }
     async init() {
@@ -99,51 +96,22 @@ class SolTransactionBuilder {
         swapTx.recentBlockhash = this.recentBlockhash;
         swapTx.lastValidBlockHeight = this.recentBlockheight + max_block_offset;
         swapTx.feePayer = this.keypair.publicKey;
-        const { sol_bundle_only, sol_tip_fee } = context.trade_runtime.settings.strategy;
-        if (!sol_bundle_only) {
-            let tip_lamports = sol_tip_fee;
-            if (tip_lamports < 5000) {
-                tip_lamports = 5000;
-            }
-            if (tip_lamports > 300000) {
-                tip_lamports = 300000;
-            }
-            let tip_instruction = web3_js_1.SystemProgram.transfer({
-                fromPubkey: this.keypair.publicKey,
-                toPubkey: new web3_js_1.PublicKey(helius_1.HELIUS_TIP_ACCOUNTS[Math.floor(Math.random() * helius_1.HELIUS_TIP_ACCOUNTS.length)]),
-                lamports: tip_lamports,
-            });
-            swapTx.instructions.push(tip_instruction);
-        }
-        swapTx.sign(this.keypair);
-        return swapTx;
-    }
-    buildTransactionForTipJito(context) {
-        const groupId = context.trade_runtime.group.id;
-        const max_block_offset = context.trade_runtime.settings.strategy.max_block_offset;
-        let tipPayer = this.jitoTipWalletManager.getNextWallet(groupId);
-        if (!tipPayer) {
-            tipPayer = this.keypair;
-        }
-        let tipAccount = (0, jito_1.getJitoTipAccount)();
-        let tip_lamports = context.trade_runtime.settings.strategy.sol_tip_fee;
+        const { sol_tip_fee } = context.trade_runtime.settings.strategy;
+        let tip_lamports = sol_tip_fee;
         if (tip_lamports < 5000) {
             tip_lamports = 5000;
         }
         if (tip_lamports > 300000) {
             tip_lamports = 300000;
         }
-        const jitoTipTx = new web3_js_1.Transaction();
-        jitoTipTx.add(web3_js_1.SystemProgram.transfer({
-            fromPubkey: tipPayer.publicKey,
-            toPubkey: new web3_js_1.PublicKey(tipAccount),
+        let tip_instruction = web3_js_1.SystemProgram.transfer({
+            fromPubkey: this.keypair.publicKey,
+            toPubkey: new web3_js_1.PublicKey(helius_1.HELIUS_TIP_ACCOUNTS[Math.floor(Math.random() * helius_1.HELIUS_TIP_ACCOUNTS.length)]),
             lamports: tip_lamports,
-        }));
-        jitoTipTx.recentBlockhash = this.recentBlockhash;
-        jitoTipTx.lastValidBlockHeight = this.recentBlockheight + max_block_offset;
-        jitoTipTx.feePayer = tipPayer.publicKey;
-        jitoTipTx.sign(tipPayer);
-        return jitoTipTx;
+        });
+        swapTx.instructions.push(tip_instruction);
+        swapTx.sign(this.keypair);
+        return swapTx;
     }
 }
 exports.SolTransactionBuilder = SolTransactionBuilder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-sol-common",
-  "version": "2.0.68",
+  "version": "2.0.70",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/quote/depth/amm_depth_calculator.ts

@@ -0,0 +1,143 @@
+/**
+ * AMM 深度计算器
+ *
+ * 给定 reserves + 价格偏移（bps），用 x*y=k 闭合公式计算可交易量。
+ * 一次乘除，零遍历。
+ *
+ * 与 CLMM 一样，给定价格范围的输出量与 fee 无关（fee 只影响需要多少 input）。
+ */
+
+import { bigIntSqrt } from './clmm_depth_calculator';
+
+export interface AmmDepthInput {
+    reserve0: string;         // token0 reserve（wei string）
+    reserve1: string;         // token1 reserve（wei string）
+    targetBps: number;        // 价格偏移（如 15, 30）
+    isBuy: boolean;           // true=买入 base token(token0), false=卖出 base token
+    /** base token 是 pool 的 token0 还是 token1 */
+    baseIsToken0: boolean;
+    token0Decimals: number;
+    token1Decimals: number;
+}
+
+export interface AmmDepthResult {
+    /** 输出 token 数量（wei） */
+    amountOutWei: bigint;
+    /** 输出 token 数量（UI 单位） */
+    amountOut: number;
+    /** 输出的 decimals */
+    outputDecimals: number;
+    /** 输入 token 数量（wei，不含 fee；池子曲线纯输入） */
+    amountInWei: bigint;
+    /** 输入 token 数量（UI 单位，不含 fee） */
+    amountIn: number;
+    /** 输入的 decimals */
+    inputDecimals: number;
+    /** 推到的目标价（quote per base，UI 单位） */
+    targetPrice: number;
+}
+
+/**
+ * 计算 AMM 池子在给定价格偏移范围内的深度
+ *
+ * 公式推导（以标准 token0/token1 为例）：
+ *   k = R0 * R1
+ *   P = R1 / R0（token0 相对 token1 的价格）
+ *
+ *   Ask（买入 token0，价格上涨）：
+ *     P_target = P * (1 + bps/10000)
+ *     R0_new = sqrt(k / P_target)
+ *     depth_token0 = R0 - R0_new
+ *
+ *   Bid（卖出 token0，价格下跌）：
+ *     P_target = P * (1 - bps/10000)
+ *     R1_new = sqrt(k * P_target)
+ *     depth_token1 = R1 - R1_new
+ *
+ * 注意：pair 的 base/quote 可能与 pool 的 token0/token1 顺序不同，
+ * 通过 baseIsToken0 参数处理。
+ */
+export function calculateAmmDepth(input: AmmDepthInput): AmmDepthResult {
+    const { targetBps, isBuy, baseIsToken0, token0Decimals, token1Decimals } = input;
+    const R0 = BigInt(input.reserve0);
+    const R1 = BigInt(input.reserve1);
+
+    if (R0 === 0n || R1 === 0n) {
+        return { amountOutWei: 0n, amountOut: 0, outputDecimals: 0, amountInWei: 0n, amountIn: 0, inputDecimals: 0, targetPrice: 0 };
+    }
+
+    const k = R0 * R1;
+    const bps = BigInt(targetBps);
+    // 精度放大因子
+    const PRECISION = 10n ** 18n;
+
+    let amountOutWei: bigint;
+    let amountInWei: bigint;
+    let outputDecimals: number;
+    let inputDecimals: number;
+
+    if (isBuy) {
+        // 买入 base token → 价格上涨 → 输出 base token
+        // base token 从池子中减少
+
+        // P = quoteReserve / baseReserve
+        // P_target = P * (1 + bps/10000) = P * (10000 + bps) / 10000
+        // baseReserve_new = sqrt(k / P_target) = sqrt(k * baseReserve / quoteReserve * 10000 / (10000 + bps))
+        //
+        // 简化：baseReserve_new = sqrt(k * 10000 / ((10000 + bps) * P))
+        //      = sqrt(k * baseReserve * 10000 / (quoteReserve * (10000 + bps)))
+
+        const [baseReserve, quoteReserve] = baseIsToken0 ? [R0, R1] : [R1, R0];
+        outputDecimals = baseIsToken0 ? token0Decimals : token1Decimals;
+        inputDecimals = baseIsToken0 ? token1Decimals : token0Decimals;
+
+        // baseReserve_new = baseReserve * sqrt(10000 / (10000+bps))
+        // quoteReserve_new = k / baseReserve_new = quoteReserve * sqrt((10000+bps) / 10000)
+        // amountOut(base) = baseReserve - baseReserve_new
+        // amountIn(quote, not fee-adjusted) = quoteReserve_new - quoteReserve
+        const baseReserveNew = baseReserve * bigIntSqrt(10000n * PRECISION) / bigIntSqrt((10000n + bps) * PRECISION);
+        const quoteReserveNew = quoteReserve * bigIntSqrt((10000n + bps) * PRECISION) / bigIntSqrt(10000n * PRECISION);
+        amountOutWei = baseReserve - baseReserveNew;
+        amountInWei = quoteReserveNew - quoteReserve;
+
+    } else {
+        // 卖出 base token → 价格下跌 → 输出 quote token
+        // quote token 从池子中减少
+
+        const [baseReserve, quoteReserve] = baseIsToken0 ? [R0, R1] : [R1, R0];
+        outputDecimals = baseIsToken0 ? token1Decimals : token0Decimals;
+        inputDecimals = baseIsToken0 ? token0Decimals : token1Decimals;
+
+        // quoteReserve_new = quoteReserve * sqrt((10000-bps) / 10000)
+        // baseReserve_new = k / quoteReserve_new = baseReserve * sqrt(10000 / (10000-bps))
+        // amountOut(quote) = quoteReserve - quoteReserve_new
+        // amountIn(base, not fee-adjusted) = baseReserve_new - baseReserve
+        if (bps >= 10000n) {
+            // 100% 偏移 → 所有 quote token；amountIn 取一个有限上界（baseReserve）
+            amountOutWei = quoteReserve;
+            amountInWei = baseReserve;  // 极端情况下池子 base 耗尽
+        } else {
+            const quoteReserveNew = quoteReserve * bigIntSqrt((10000n - bps) * PRECISION) / bigIntSqrt(10000n * PRECISION);
+            const baseReserveNew = baseReserve * bigIntSqrt(10000n * PRECISION) / bigIntSqrt((10000n - bps) * PRECISION);
+            amountOutWei = quoteReserve - quoteReserveNew;
+            amountInWei = baseReserveNew - baseReserve;
+        }
+    }
+
+    const amountOut = Number(amountOutWei) / Math.pow(10, outputDecimals);
+    const amountIn = Number(amountInWei) / Math.pow(10, inputDecimals);
+
+    // 计算目标价（quote per base，UI 单位）
+    // 推到目标价后的池子状态：基于 P_target = P * (1 ± bps/10000)
+    const baseDec = baseIsToken0 ? token0Decimals : token1Decimals;
+    const quoteDec = baseIsToken0 ? token1Decimals : token0Decimals;
+    const baseReserveUi = Number(baseIsToken0 ? R0 : R1) / Math.pow(10, baseDec);
+    const quoteReserveUi = Number(baseIsToken0 ? R1 : R0) / Math.pow(10, quoteDec);
+    const midPrice = quoteReserveUi / baseReserveUi;
+    const bpsNum = Number(targetBps);
+    const targetPrice = isBuy
+        ? midPrice * (10000 + bpsNum) / 10000
+        : midPrice * (10000 - bpsNum) / 10000;
+
+    return { amountOutWei, amountOut, outputDecimals, amountInWei, amountIn, inputDecimals, targetPrice };
+}

package/src/quote/depth/index.ts

@@ -2,8 +2,9 @@
  * 深度计算模块（Solana，tier 版）
  *
  * port 自 SUI `ttd-sui-common/src/quote/depth/index.ts`（同源 BSC），差异（有理由的偏离）：
- *   · **仅 CLMM**：Solana 三个 CLMM（Raydium/Orca/ByReal）全是 Uniswap V3 风格集中流动性 X64；
- *     AMM/DAMM 走各自路径，无统一深度引擎 → 暂只点亮 buildClmmDepth。
+ *   · **CLMM + AMM**：三个 CLMM（Raydium/Orca/ByReal）全是 Uniswap V3 风格集中流动性 X64 → buildClmmDepth；
+ *     两个 AMM（Raydium AMM/CPMM）是 x·y=k 恒定乘积 → buildAmmDepth（reserve 上闭式）；
+ *     DAMMv2（CP-AMM 单 sqrtPrice 区间）复用 buildClmmDepth(ticks=[])；DLMM bin 深度待做。
  *   · **X64**：调用 X64 版 clmm_depth_calculator（见同目录，逐字照搬 SUI）。
  *   · **tick + sqrtPriceX64 由调用方物化**：各 DEX 把本地 tickArray cache 的已初始化 tick 配
  *     **共享 TickMath**（`../tick/clmm_tick_math` getSqrtPriceX64FromTick）算的 sqrtPriceX64，
@@ -24,9 +25,12 @@ import {
 } from '@clonegod/ttd-core/dist';
 import { resolveTradeDirection } from '../../utils/trade_direction';
 import { DepthTick, calculateClmmDepth, priceFromSqrtX64 } from './clmm_depth_calculator';
+import { calculateAmmDepth } from './amm_depth_calculator';
 
 export { calculateClmmDepth, priceFromSqrtX64, computeTargetSqrtX64, bigIntSqrt, swapExactInClmm } from './clmm_depth_calculator';
 export type { DepthTick, ClmmDepthInput, DepthResult, SwapExactInInput, SwapExactInResult } from './clmm_depth_calculator';
+export { calculateAmmDepth } from './amm_depth_calculator';
+export type { AmmDepthInput, AmmDepthResult } from './amm_depth_calculator';
 
 // ========== 启动日志一次性输出 ==========
 let _depthPctLogged = false;
@@ -40,8 +44,10 @@ function logDepthLevelsOnce(): void {
 /**
  * 池子曲线纯输入 → 用户实付（含费）：
  *   amountInGross = amountInNet / (1 - feeRate)；feeAmount = amountInGross - amountInNet
+ *
+ * 导出供 DEX 专有 depth 构建复用（如 DLMM 离散 bin 深度，在各自包内但 tier 语义统一）。
  */
-function grossUpFee(amountInNet: number, feeRateBps: number): { amountInGross: number; feeAmount: number } {
+export function grossUpFee(amountInNet: number, feeRateBps: number): { amountInGross: number; feeAmount: number } {
     if (feeRateBps <= 0 || amountInNet <= 0) return { amountInGross: amountInNet, feeAmount: 0 };
     const feeRatio = feeRateBps / 10000;
     const amountInGross = amountInNet / (1 - feeRatio);
@@ -49,7 +55,8 @@ function grossUpFee(amountInNet: number, feeRateBps: number): { amountInGross: n
 }
 
 // ========== 把多档 tier 装配成 QuoteEntry（主档镜像顶层）==========
-function assembleEntry(tiers: QuoteTier[]): QuoteEntry {
+/** 导出供 DEX 专有 depth 构建复用（tier 语义统一）。 */
+export function assembleEntry(tiers: QuoteTier[]): QuoteEntry {
     const def = tiers.find(t => t.pct === DEFAULT_TIER_PCT) ?? tiers[0];
     return {
         price: def.price, amount: def.amount, amount_in: def.amount_in, amount_in_usd: def.amount_in_usd,
@@ -165,3 +172,101 @@ export function buildClmmDepth(input: BuildClmmDepthInput): QuoteDepthOutput | u
         return undefined;
     }
 }
+
+// ========== AMM 通用深度构建 ==========
+//
+// port 自 BSC `arb-chain-bsc/.../quote/depth/index.ts` buildAmmDepth；差异（有理由的偏离）：
+//   · **baseIsToken0 由调用方传**（用链上 mintA/mintB 判定），不在此用地址 lowercase 比较——
+//     Solana 地址 base58 大小写敏感，不可 lowercase（与 buildClmmDepth 一致）。
+//   · reserve0/reserve1 = 链上 token0(mintA)/token1(mintB) 的 reserve（wei string）。
+
+export interface BuildAmmDepthInput {
+    poolInfo: StandardPoolInfoType;
+    /** token0(=链上 mintA) 的 reserve（wei string） */
+    reserve0: string;
+    /** token1(=链上 mintB) 的 reserve（wei string） */
+    reserve1: string;
+    /** base token 是否为链上 token0(=mintA)；调用方用链上 mint 判定（base58 大小写敏感） */
+    baseIsToken0: boolean;
+    basePriceUsd: number;
+    quotePriceUsd: number;
+    /**
+     * 池子 effective fee rate (bps)，必填。各 DEX 从配置 fee_rate（market-data 强制整数 ≥1）传入。
+     * 错则 verify 跨源 diff 系统性偏移会暴露。
+     */
+    feeRateBps: number;
+}
+
+/**
+ * 通用 AMM 深度构建：多档（默认 5 档）ask/bid 深度，从内存 reserve 零额外 RPC 计算（x·y=k 闭式）。
+ */
+export function buildAmmDepth(input: BuildAmmDepthInput): QuoteDepthOutput | undefined {
+    logDepthLevelsOnce();
+    const pctLevels = getDepthPricePctLevels();
+    if (pctLevels.length === 0) return undefined;
+
+    const { poolInfo, reserve0, reserve1, baseIsToken0, basePriceUsd, quotePriceUsd, feeRateBps } = input;
+    if (feeRateBps == null || feeRateBps < 0) {
+        log_debug(`[Depth] ${poolInfo.pool_name} AMM: invalid feeRateBps=${feeRateBps}, skip`, '');
+        return undefined;
+    }
+
+    try {
+        const dir = resolveTradeDirection(poolInfo, true);
+        const baseToken = dir.baseToken;
+        const quoteToken = dir.quoteToken;
+
+        // 中间价：从 reserve 比值算（UI 单位）
+        const baseReserveUi = Number(BigInt(baseIsToken0 ? reserve0 : reserve1)) / Math.pow(10, baseToken.decimals);
+        const quoteReserveUi = Number(BigInt(baseIsToken0 ? reserve1 : reserve0)) / Math.pow(10, quoteToken.decimals);
+        const midPrice = quoteReserveUi / baseReserveUi;
+
+        const askTiers: QuoteTier[] = [];
+        const bidTiers: QuoteTier[] = [];
+
+        for (const pct of pctLevels) {
+            const bps = Math.round(pct * 100);
+
+            const askResult = calculateAmmDepth({
+                reserve0, reserve1, targetBps: bps, isBuy: true, baseIsToken0,
+                token0Decimals: baseIsToken0 ? baseToken.decimals : quoteToken.decimals,
+                token1Decimals: baseIsToken0 ? quoteToken.decimals : baseToken.decimals,
+            });
+            const bidResult = calculateAmmDepth({
+                reserve0, reserve1, targetBps: bps, isBuy: false, baseIsToken0,
+                token0Decimals: baseIsToken0 ? baseToken.decimals : quoteToken.decimals,
+                token1Decimals: baseIsToken0 ? quoteToken.decimals : baseToken.decimals,
+            });
+
+            // Ask: amount_in 是 quote token；Bid: amount_in 是 base token
+            const askGross = grossUpFee(askResult.amountIn, feeRateBps);
+            const bidGross = grossUpFee(bidResult.amountIn, feeRateBps);
+
+            // 【强制·原则2】tier.price = effective avg price including fee = amount_in_gross / amount_out
+            //   跟 chain swap exec_price 严格同语义；禁止改回 marginal / 不含 fee 形态（G4 事故根因）。
+            const askEffPrice = askResult.amountOut > 0 ? askGross.amountInGross / askResult.amountOut : askResult.targetPrice;
+            const bidEffPrice = bidGross.amountInGross > 0 ? bidResult.amountOut / bidGross.amountInGross : bidResult.targetPrice;
+
+            askTiers.push({
+                pct, price: askEffPrice, amount: askResult.amountOut,
+                amount_in: askGross.amountInGross, amount_in_usd: askGross.amountInGross * quotePriceUsd,
+                fee: askGross.feeAmount, fee_usd: askGross.feeAmount * quotePriceUsd,
+            });
+            bidTiers.push({
+                pct, price: bidEffPrice, amount: bidResult.amountOut,
+                amount_in: bidGross.amountInGross, amount_in_usd: bidGross.amountInGross * basePriceUsd,
+                fee: bidGross.feeAmount, fee_usd: bidGross.feeAmount * basePriceUsd,
+            });
+        }
+
+        return {
+            mid_price: midPrice,
+            fee_rate_bps: feeRateBps,
+            ask: assembleEntry(askTiers),
+            bid: assembleEntry(bidTiers),
+        };
+    } catch (error) {
+        log_debug(`[Depth] ${poolInfo.pool_name} AMM depth failed: ${(error as Error).message}`, '');
+        return undefined;
+    }
+}

package/src/trade/index.ts

@@ -2,6 +2,5 @@ export * from './tx_result_check'
 export * from './tx_result_parse'
 export * from './tx_builder'
 export * from './send'
-export * from './jito_tip_wallets'
 export * from './sol_gas_cache'
 

package/src/trade/send/send_tx.ts

@@ -1,6 +1,5 @@
 import { Transaction, VersionedTransaction } from '@solana/web3.js';
 import { sendTxWithHelius } from './helius';
-import { sendBundleWithJito, sendBundleWithJitoMultiIps } from './jito';
 import { getSignature } from '../../common';
 import { TradeContext } from '@clonegod/ttd-core/dist';
 import { set_sol_gas_fee } from '../sol_gas_cache';
@@ -31,30 +30,6 @@ export class TransactionSender {
         return await sendTxWithHelius(singedTxBase64, swqos_only)
     }
 
-    /**
-     * 使用Jito Bundle 发送交易
-     * - use_multi_ips=true, 使用多台服务器向jito提交交易（缓解jito的限流）
-     * - use_multi_ips=false, 本地直接向jito提交交易
-     * 
-     * @param mainTx 主交易
-     * @param tipTx 小费交易
-     * @param use_multi_ips true：多节点；false: 单节点
-     * @returns bundleId
-     */
-    async sendBundle(context:TradeContext, mainTx: Transaction | VersionedTransaction, tipTx: Transaction | VersionedTransaction, use_multi_ips: boolean=false): Promise<string> {
-        const mainTxHash = getSignature(mainTx)
-        set_transaciton_gas_cost(mainTxHash, context)
-
-        const mainTxBase64 = serializeTransactionBase64(mainTx)
-        const tipTxBase64 = serializeTransactionBase64(tipTx)
-        
-        if(use_multi_ips) {
-            return await sendBundleWithJitoMultiIps(mainTxHash, mainTxBase64, tipTxBase64)
-        } else {
-            return await sendBundleWithJito(mainTxBase64, tipTxBase64)
-        }
-    }
-
 }
 
 

package/src/trade/tx_builder.ts

@@ -4,8 +4,6 @@ import { LAMPORTS_PER_MICRO_LAMPORTS } from "../common";
 import { SolanaBlockMetaUpdateEvent } from "../types";
 import { SolanaTradeAppConfig } from "../appconfig/SolanaTradeAppConfig";
 import { HELIUS_TIP_ACCOUNTS } from "./send/helius";
-import { getJitoTipAccount } from "./send/jito";
-import { JitoTipWalletManager } from "./jito_tip_wallets";
 
 /**
  * Jito Sandwich Mitigation: jitodontfront 账户
@@ -71,13 +69,10 @@ export class SolTransactionBuilder {
     recentBlockhash: string
     recentBlockheight: number
 
-    jitoTipWalletManager: JitoTipWalletManager
-
     constructor(appConfig: SolanaTradeAppConfig) {
         this.appConfig = appConfig
         this.connection = appConfig.connection
         this.keypair = appConfig.keypair
-        this.jitoTipWalletManager = new JitoTipWalletManager()
         this.init()
     }
 
@@ -175,74 +170,29 @@ export class SolTransactionBuilder {
         swapTx.lastValidBlockHeight = this.recentBlockheight + max_block_offset
         swapTx.feePayer = this.keypair.publicKey
 
-        const { sol_bundle_only, sol_tip_fee } = context.trade_runtime.settings.strategy
-
-        // sol_bundle_only = false, 使用 Helius Sender
-        // sol_bundle_only = true, 使用 Jito Bundle - 不需要给Helius小费
-        if (!sol_bundle_only) {
-            // 使用 Helius Sender:
-            // 1、swqos_only: 至少 5000 lamports 小费
-            //   -> transaction must send a tip of at least 5000 lamports to one of the following Helius wallets: [xxx, ...]
-            // 2、swqos + jito: 至少 0.0002 SOL 小费 -> lamports = 0.0002 * LAMPORTS_PER_SOL
-            //   -> Requires minimum 0.0002 SOL tip.
-            let tip_lamports = sol_tip_fee
-            if (tip_lamports < 5000) {
-                tip_lamports = 5000
-            }
-            if (tip_lamports > 300000) {
-                tip_lamports = 300000
-            }
-            let tip_instruction = SystemProgram.transfer({
-                fromPubkey: this.keypair.publicKey,
-                toPubkey: new PublicKey(HELIUS_TIP_ACCOUNTS[Math.floor(Math.random() * HELIUS_TIP_ACCOUNTS.length)]),
-                lamports: tip_lamports,
-            })
-            swapTx.instructions.push(tip_instruction)
-        }
-
-        swapTx.sign(this.keypair)
-
-        return swapTx
-    }
-
+        const { sol_tip_fee } = context.trade_runtime.settings.strategy
 
-
-    /**
-     * build transaction for tip jito
-     */
-    buildTransactionForTipJito(context: TradeContext): Transaction {
-        const groupId = context.trade_runtime.group.id
-        const max_block_offset = context.trade_runtime.settings.strategy.max_block_offset
-
-        let tipPayer = this.jitoTipWalletManager.getNextWallet(groupId)
-        if (!tipPayer) {
-            tipPayer = this.keypair
-        }
-
-        let tipAccount = getJitoTipAccount()
-        let tip_lamports = context.trade_runtime.settings.strategy.sol_tip_fee
+        // 发送只走 Helius Sender，必须附带最低小费：
+        // 1、swqos_only: 至少 5000 lamports 小费
+        //   -> transaction must send a tip of at least 5000 lamports to one of the Helius tip wallets
+        // 2、swqos + jito: 至少 0.0002 SOL 小费 -> lamports = 0.0002 * LAMPORTS_PER_SOL
+        let tip_lamports = sol_tip_fee
         if (tip_lamports < 5000) {
             tip_lamports = 5000
         }
         if (tip_lamports > 300000) {
             tip_lamports = 300000
         }
+        let tip_instruction = SystemProgram.transfer({
+            fromPubkey: this.keypair.publicKey,
+            toPubkey: new PublicKey(HELIUS_TIP_ACCOUNTS[Math.floor(Math.random() * HELIUS_TIP_ACCOUNTS.length)]),
+            lamports: tip_lamports,
+        })
+        swapTx.instructions.push(tip_instruction)
+
+        swapTx.sign(this.keypair)
 
-        const jitoTipTx = new Transaction();
-        jitoTipTx.add(
-            SystemProgram.transfer({
-                fromPubkey: tipPayer.publicKey,
-                toPubkey: new PublicKey(tipAccount),
-                lamports: tip_lamports,
-            }),
-        );
-        jitoTipTx.recentBlockhash = this.recentBlockhash
-        jitoTipTx.lastValidBlockHeight = this.recentBlockheight + max_block_offset
-        jitoTipTx.feePayer = tipPayer.publicKey;
-
-        jitoTipTx.sign(tipPayer)
-
-        return jitoTipTx
+        return swapTx
     }
 
 }

package/src/trade/jito_tip_wallets.ts

@@ -1,143 +0,0 @@
-import { Keypair } from '@solana/web3.js';
-import { log_info, log_warn, log_error } from '@clonegod/ttd-core/dist';
-import bs58 from 'bs58';
-import * as fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-/**
- * 钱包配置接口
- */
-export interface WalletConfig {
-    public_key: string;
-    private_key: string;
-    type: string;  // main | sub
-    keypair: Keypair;  // 添加 Keypair 字段
-}
-
-/**
- * 分组配置接口
- */
-export interface GroupConfig {
-    group_id: string;
-    tip_wallets: WalletConfig[];
-}
-
-/**
- * Jito Tip 钱包管理器
- * 
- * 功能：
- * 1. 从文件加载 tip wallets
- * 2. 返回下一个钱包（轮询）
- */
-export class JitoTipWalletManager {
-    private readonly jito_tip_wallet_filename: string = 'jito_tip_wallet.json';
-    private walletConfigs: GroupConfig[] = [];
-    private walletIndexMap: Map<string, number> = new Map();
-
-    constructor() {
-        this.loadWalletConfigs();
-    }
-
-    /**
-     * 从私钥创建 Keypair
-     */
-    private createKeypair(privateKeyBase58: string): Keypair {
-        const privateKeyBytes = bs58.decode(privateKeyBase58);
-        return Keypair.fromSecretKey(privateKeyBytes);
-    }
-
-    /**
-     * 从文件加载钱包配置
-     */
-    private loadWalletConfigs(): void {
-        try {
-            // 从环境变量获取配置文件路径
-            let jito_tip_wallet_path = process.env.JITO_TIP_WALLET_PATH || '';
-            if (!jito_tip_wallet_path.startsWith('/')) {
-                jito_tip_wallet_path = path.join(os.homedir(), 'data', 'keypairs', this.jito_tip_wallet_filename);
-            }
-
-            if (!fs.existsSync(jito_tip_wallet_path)) {
-                log_warn(`[JitoTipWalletManager] 配置文件${this.jito_tip_wallet_filename}不存在！路径: ${jito_tip_wallet_path}`);
-                this.walletConfigs = [];
-                return;
-            }
-
-            const configData = fs.readFileSync(jito_tip_wallet_path, 'utf-8');
-            this.walletConfigs = JSON.parse(configData);
-
-            // 为每个钱包生成 KeyPair
-            this.walletConfigs.forEach(group => {
-                group.tip_wallets.forEach(wallet => {
-                    try {
-                        wallet.keypair = this.createKeypair(wallet.private_key);
-                    } catch (error) {
-                        log_error(`[JitoTipWalletManager] 生成钱包 KeyPair 失败 - public_key: ${wallet.public_key}`, error);
-                    }
-                });
-            });
-
-            log_info(`[JitoTipWalletManager] 成功加载配置文件: ${jito_tip_wallet_path}`);
-            
-            // 加载完成后打印钱包信息
-            this.printWalletInfo();
-        } catch (error) {
-            log_error('[JitoTipWalletManager] 加载钱包配置时出错:', error);
-            this.walletConfigs = [];
-        }
-    }
-
-    /**
-     * 打印钱包信息（用于调试）
-     */
-    private printWalletInfo(): void {
-        log_info('\n=== Tip钱包配置信息 ===');
-        if (this.walletConfigs.length === 0) {
-            log_info('没有找到任何钱包配置');
-            return;
-        }
-
-        this.walletConfigs.forEach(group => {
-            log_info(`\n分组: ${group.group_id}`);
-            log_info(`钱包数量: ${group.tip_wallets.length}`);
-            group.tip_wallets.forEach((wallet, index) => {
-                const keypairStatus = wallet.keypair ? '✓' : '✗';
-                log_info(`  ${index + 1}. ${wallet.public_key}${wallet.type ? ` (${wallet.type})` : ''} [KeyPair: ${keypairStatus}]`);
-            });
-        });
-        log_info('\n===================\n');
-    }
-
-    /**
-     * 获取下一个钱包（轮询）
-     * @param groupId 分组ID
-     * @returns 钱包配置，如果未找到则返回 null
-     */
-    public getNextWallet(groupId: string): Keypair | null {
-        const group = this.walletConfigs.find(g => g.group_id === groupId);
-        if (!group) {
-            log_warn(`[JitoTipWalletManager] 未找到group_id对应的钱包组: ${groupId}`);
-            return null;
-        }
-
-        if (group.tip_wallets.length === 0) {
-            log_warn(`[JitoTipWalletManager] group_id: ${groupId} 没有配置钱包`);
-            return null;
-        }
-
-        // 获取当前索引，如果不存在则初始化为0
-        let currentIndex = this.walletIndexMap.get(groupId) || 0;
-
-        // 获取下一个钱包
-        const wallet = group.tip_wallets[currentIndex];
-
-        // 更新索引，如果达到列表末尾则重置为0
-        currentIndex = (currentIndex + 1) % group.tip_wallets.length;
-        this.walletIndexMap.set(groupId, currentIndex);
-
-        return wallet.keypair;
-    }
-}
-
-

package/src/trade/send/jito.ts

@@ -1,132 +0,0 @@
-import { log_warn } from "@clonegod/ttd-core/dist";
-import axios, { AxiosError } from "axios";
-import { getHttpClient } from "./http_client";
-
-export const JITO_TIP_ACCOUNTS = [
-    "DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh",
-    "DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL",
-    "3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT",
-    "96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5",
-    "ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt",
-    "Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY",
-    "ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49",
-    "HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe"
-]
-
-export class JitoUtils {
-    static jitoTipAccounts: string[] = []
-    static jitoTipAccountUrl = 'https://mainnet.block-engine.jito.wtf/api/v1/getTipAccounts'
-
-    static async init(): Promise<void> {
-        return JitoUtils.fetchJitoTipAccounts().then((accounts) => {
-            JitoUtils.jitoTipAccounts = accounts;
-            console.log(`fetchJitoTipAccounts success: ${accounts.length} accounts`, accounts)
-        }).catch((error) => {
-            log_warn(`fetchJitoTipAccounts failed!`, {
-                url: JitoUtils.jitoTipAccountUrl,
-                error: error.message
-            });
-        });
-    }
-
-    static async fetchJitoTipAccounts(): Promise<string[]> {
-        const response = await axios.post<{ result: string[] }>(JitoUtils.jitoTipAccountUrl, {
-            jsonrpc: '2.0',
-            id: 1,
-            method: 'getTipAccounts',
-            params: []
-        })
-        return response.data.result;
-    }
-}
-
-
-export const getJitoTipAccount = (): string => {
-    let jito_tip_accounts = JitoUtils.jitoTipAccounts
-    if (jito_tip_accounts.length === 0) {
-        jito_tip_accounts = JITO_TIP_ACCOUNTS
-    }
-    return jito_tip_accounts[Math.floor(Math.random() * jito_tip_accounts.length)];
-}
-
-JitoUtils.init()
-
-// -----------------------------------------------------------
-
-export const sendBundleWithJito = async (mainTxBase64: string, tipTxBase64: string): Promise<string> => {
-    let url = process.env.JITO_SEND_BUNDLE_URL || 'https://tokyo.mainnet.block-engine.jito.wtf/api/v1/bundles'
-
-    // 使用共享的 axios 实例，复用连接池
-    const client = getHttpClient(url)
-
-    // Bundle 顺序: [mainTx, tipTx]
-    // 根据 Jito Sandwich Mitigation 规则 (https://docs.jito.wtf/lowlatencytxnsend/#sandwich-mitigation):
-    // - 如果主交易包含 jitodontfront 账户，它必须在 bundle 的第一个位置（索引 0）
-    // - 允许的模式: [tx_with_dont_front, tip]
-    // - 不允许的模式: [tip, tx_with_dont_front]
-    const requestData = {
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'sendBundle',
-        params: [
-            [mainTxBase64, tipTxBase64],
-            {
-                "encoding": "base64"
-            }
-        ]
-    };
-
-    try {
-        const response = await client.post<{ result: string }>(url, requestData)
-        // {
-        //     jsonrpc: '2.0',
-        //     result: 'e62062b4af6963bb0f67fea429f97e4f4fee59851a4ef65154b9f49b5995b5be', // bundle id
-        //     id: 1
-        // }
-        // console.dir(response.data, { depth: null })
-        const bundleId = response.data.result;
-        console.log(`[sendBundleWithJito] bundleId: ${bundleId}`);
-        
-        return bundleId;
-    } catch (error) {
-        if(error instanceof AxiosError) {
-            // 提取关键错误信息
-            const status = error.response?.status;
-            const statusText = error.response?.statusText;
-            
-            log_warn(`[sendBundleWithJito] Request failed: ${status} - ${statusText}`);
-        } else {
-            log_warn(`[sendBundleWithJito] Unexpected error: ${url} - ${error.message}`);
-        }
-    }
-}
-
-
-export const sendBundleWithJitoMultiIps = async (mainTxHash: string, mainTxBase64: string, tipTxBase64: string): Promise<string> => {
-    let ips = (process.env.JITO_SEND_BUNDLE_SERVER_IPS || '127.0.0.1').split(',')
-    let urls = ips.map(ip => `http://${ip}:10429/solana/send_tx`)
-
-    // Bundle 顺序: [mainTx, tipTx]
-    // 与 sendBundleWithJito 保持一致，符合 Jito Sandwich Mitigation 规则
-    const body = {
-        trace_id: '',
-        txid: mainTxHash,
-        encoding: 'base64',    // base64
-        encoded_tx: [mainTxBase64, tipTxBase64].join(','),  // bundle: mainTx, tipTx
-        max_retry: 3
-    }
-
-    Promise.all(urls.map(async (url) => {
-        try {
-            const client = getHttpClient(url)
-            const response = await client.post<{ result: string }>(url, body)
-            return response.data.result;
-        } catch (error) {
-            console.error(`sendBundleWithJitoByMultiIps error: ${url}`, error)
-        }
-    }))
-
-    return 'success';
-}
-
-