@clonegod/ttd-sol-common 2.0.16 → 2.0.18

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

@@ -1,3 +1,3 @@
 import { Transaction } from "@solana/web3.js";
-export declare const HELIUS_JITO_TIP_ACCOUNTS: string[];
-export declare const sendTxWithHelius: (signedTransaction: Transaction, send_jito?: boolean) => Promise<string>;
+export declare const HELIUS_TIP_ACCOUNTS: string[];
+export declare const sendTxWithHelius: (signedTransaction: Transaction, tip_helius: boolean) => Promise<string>;

package/dist/trade/send/helius.js

@@ -3,9 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendTxWithHelius = exports.HELIUS_JITO_TIP_ACCOUNTS = void 0;
+exports.sendTxWithHelius = exports.HELIUS_TIP_ACCOUNTS = void 0;
 const axios_1 = __importDefault(require("axios"));
-exports.HELIUS_JITO_TIP_ACCOUNTS = [
+exports.HELIUS_TIP_ACCOUNTS = [
     "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
     "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
     "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
@@ -17,9 +17,9 @@ exports.HELIUS_JITO_TIP_ACCOUNTS = [
     "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
     "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
 ];
-const sendTxWithHelius = async (signedTransaction, send_jito = true) => {
-    let url = 'http://tyo-sender.helius-rpc.com/fast';
-    if (!send_jito) {
+const sendTxWithHelius = async (signedTransaction, tip_helius) => {
+    let url = process.env.HELIUS_SEND_TX_URL || 'http://tyo-sender.helius-rpc.com/fast';
+    if (!tip_helius) {
         url = url + "?swqos_only=true";
     }
     const response = await axios_1.default.post(url, {
@@ -35,7 +35,6 @@ const sendTxWithHelius = async (signedTransaction, send_jito = true) => {
             }
         ]
     });
-    console.dir(response.data, { depth: null });
     return response.data.result;
 };
 exports.sendTxWithHelius = sendTxWithHelius;

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

@@ -0,0 +1,9 @@
+import { Transaction } from "@solana/web3.js";
+export declare const JITO_TIP_ACCOUNTS: string[];
+export declare class JitoUtils {
+    static jitoTipAccounts: string[];
+    static init(): Promise<void>;
+    static fetchJitoTipAccounts(): Promise<string[]>;
+}
+export declare const getJitoTipAccount: () => string;
+export declare const sendBundleWithJito: (signedTransactions: Transaction[]) => Promise<string>;

package/dist/trade/send/jito.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendBundleWithJito = exports.getJitoTipAccount = exports.JitoUtils = exports.JITO_TIP_ACCOUNTS = void 0;
+const axios_1 = __importDefault(require("axios"));
+exports.JITO_TIP_ACCOUNTS = [
+    "DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh",
+    "DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL",
+    "3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT",
+    "96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5",
+    "ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt",
+    "Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY",
+    "ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49",
+    "HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe"
+];
+class JitoUtils {
+    static async init() {
+        return JitoUtils.fetchJitoTipAccounts().then((accounts) => {
+            JitoUtils.jitoTipAccounts = accounts;
+            console.log(`fetchJitoTipAccounts success: ${accounts.length} accounts`, accounts);
+        });
+    }
+    static async fetchJitoTipAccounts() {
+        const response = await axios_1.default.post('https://mainnet.block-engine.jito.wtf/api/v1/getTipAccounts', {
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'getTipAccounts',
+            params: []
+        });
+        return response.data.result;
+    }
+}
+exports.JitoUtils = JitoUtils;
+JitoUtils.jitoTipAccounts = [];
+const getJitoTipAccount = () => {
+    let jito_tip_accounts = JitoUtils.jitoTipAccounts;
+    if (JitoUtils.jitoTipAccounts.length === 0) {
+        jito_tip_accounts = exports.JITO_TIP_ACCOUNTS;
+    }
+    return jito_tip_accounts[Math.floor(Math.random() * jito_tip_accounts.length)];
+};
+exports.getJitoTipAccount = getJitoTipAccount;
+JitoUtils.init();
+const sendBundleWithJito = async (signedTransactions) => {
+    let url = process.env.JITO_SEND_BUNDLE_URL || 'https://tokyo.mainnet.block-engine.jito.wtf/api/v1/bundles';
+    const response = await axios_1.default.post(url, {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'sendBundle',
+        params: [
+            signedTransactions.map(tx => Buffer.from(tx.serialize()).toString('base64')),
+            {
+                "encoding": "base64"
+            }
+        ]
+    });
+    console.dir(response.data, { depth: null });
+    return response.data.result;
+};
+exports.sendBundleWithJito = sendBundleWithJito;

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

@@ -1,6 +1,6 @@
 import { Transaction } from '@solana/web3.js';
 export declare class TransactionSender {
     constructor();
-    sendTransaction(singedTransactions: Transaction[]): Promise<string>;
+    sendTransaction(singedTransactions: Transaction[], tip_helius: boolean): Promise<string>;
     sendBundle(signedTransactions: Transaction[]): Promise<string>;
 }

package/dist/trade/send/send_tx.js

@@ -2,19 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionSender = void 0;
 const helius_1 = require("./helius");
+const jito_1 = require("./jito");
 class TransactionSender {
     constructor() {
     }
-    async sendTransaction(singedTransactions) {
+    async sendTransaction(singedTransactions, tip_helius) {
         if (singedTransactions.length === 1) {
-            return await (0, helius_1.sendTxWithHelius)(singedTransactions[0]);
+            return await (0, helius_1.sendTxWithHelius)(singedTransactions[0], tip_helius);
         }
         else {
             return await this.sendBundle(singedTransactions);
         }
     }
     async sendBundle(signedTransactions) {
-        throw new Error('not implemented');
+        return await (0, jito_1.sendBundleWithJito)(signedTransactions);
     }
 }
 exports.TransactionSender = TransactionSender;

package/dist/trade/tx_builder.d.ts

@@ -10,10 +10,9 @@ export declare class SolTransactionBuilder {
     constructor(appConfig: SolanaTradeAppConfig);
     init(): Promise<void>;
     private handleBlockUpdateEvent;
-    execute(context: TradeContext): Promise<string>;
-    getPreInstructions(context: TradeContext): TransactionInstruction[];
-    getPostInstructions(context: TradeContext): TransactionInstruction[];
-    buildTransactionForSwap(context: TradeContext, swapInstructions: TransactionInstruction[], send_jito?: boolean): Transaction;
-    getHeliusJitoTipInstruction(context: TradeContext): TransactionInstruction;
-    buildTransactionForTip(context: TradeContext, tipAccount: string, tipAmount: number, tipPayer?: Keypair): Transaction;
+    private getPreInstructions;
+    private getPostInstructions;
+    buildTransactionForSwap(context: TradeContext, swapInstructions: TransactionInstruction[], tip_helius: boolean): Transaction;
+    private getHeliusTipInstruction;
+    buildTransactionForTipJito(context: TradeContext, tipPayer?: Keypair): Transaction;
 }

package/dist/trade/tx_builder.js

@@ -5,6 +5,7 @@ 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");
 class SolTransactionBuilder {
     constructor(appConfig) {
         this.appConfig = appConfig;
@@ -21,9 +22,6 @@ class SolTransactionBuilder {
         this.recentBlockhash = blockHash;
         this.recentBlockheight = blockHeight;
     }
-    execute(context) {
-        throw new Error('not implemented!!!');
-    }
     getPreInstructions(context) {
         const cu_limit = context.pool_info.cu_limit || 600000;
         const sol_priority_fee_lamports = context.trade_runtime.settings.strategy.sol_priority_fee;
@@ -39,7 +37,7 @@ class SolTransactionBuilder {
     getPostInstructions(context) {
         return [];
     }
-    buildTransactionForSwap(context, swapInstructions, send_jito = true) {
+    buildTransactionForSwap(context, swapInstructions, tip_helius) {
         const max_block_offset = context.trade_runtime.settings.strategy.max_block_offset;
         const swapTx = new web3_js_1.Transaction();
         const preInstructions = this.getPreInstructions(context);
@@ -48,37 +46,39 @@ class SolTransactionBuilder {
         swapTx.recentBlockhash = this.recentBlockhash;
         swapTx.lastValidBlockHeight = this.recentBlockheight + max_block_offset;
         swapTx.feePayer = this.keypair.publicKey;
-        if (send_jito) {
-            let jitoTipInstruction = this.getHeliusJitoTipInstruction(context);
+        if (tip_helius) {
+            let jitoTipInstruction = this.getHeliusTipInstruction(context);
             swapTx.instructions.push(jitoTipInstruction);
         }
         swapTx.sign(this.keypair);
         return swapTx;
     }
-    getHeliusJitoTipInstruction(context) {
-        let tip_lamports = Math.max(context.trade_runtime.settings.strategy.sol_tip_fee, 0.0002 * web3_js_1.LAMPORTS_PER_SOL);
+    getHeliusTipInstruction(context) {
+        let tip_lamports = Math.min(context.trade_runtime.settings.strategy.sol_tip_fee, 0.0002 * web3_js_1.LAMPORTS_PER_SOL);
         return web3_js_1.SystemProgram.transfer({
             fromPubkey: this.keypair.publicKey,
-            toPubkey: new web3_js_1.PublicKey(helius_1.HELIUS_JITO_TIP_ACCOUNTS[Math.floor(Math.random() * helius_1.HELIUS_JITO_TIP_ACCOUNTS.length)]),
+            toPubkey: new web3_js_1.PublicKey(helius_1.HELIUS_TIP_ACCOUNTS[Math.floor(Math.random() * helius_1.HELIUS_TIP_ACCOUNTS.length)]),
             lamports: tip_lamports,
         });
     }
-    buildTransactionForTip(context, tipAccount, tipAmount, tipPayer = undefined) {
+    buildTransactionForTipJito(context, tipPayer = undefined) {
         const max_block_offset = context.trade_runtime.settings.strategy.max_block_offset;
         if (!tipPayer) {
             tipPayer = this.keypair;
         }
-        const tipTx = new web3_js_1.Transaction();
-        tipTx.add(web3_js_1.SystemProgram.transfer({
+        let tipAccount = (0, jito_1.getJitoTipAccount)();
+        let tipAmount = Math.min(context.trade_runtime.settings.strategy.sol_tip_fee, 0.0002 * web3_js_1.LAMPORTS_PER_SOL);
+        const jitoTipTx = new web3_js_1.Transaction();
+        jitoTipTx.add(web3_js_1.SystemProgram.transfer({
             fromPubkey: tipPayer.publicKey,
             toPubkey: new web3_js_1.PublicKey(tipAccount),
             lamports: tipAmount,
         }));
-        tipTx.recentBlockhash = this.recentBlockhash;
-        tipTx.lastValidBlockHeight = this.recentBlockheight + max_block_offset;
-        tipTx.feePayer = tipPayer.publicKey;
-        tipTx.sign(tipPayer);
-        return tipTx;
+        jitoTipTx.recentBlockhash = this.recentBlockhash;
+        jitoTipTx.lastValidBlockHeight = this.recentBlockheight + max_block_offset;
+        jitoTipTx.feePayer = tipPayer.publicKey;
+        jitoTipTx.sign(tipPayer);
+        return jitoTipTx;
     }
 }
 exports.SolTransactionBuilder = SolTransactionBuilder;

package/package.json

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

package/src/trade/send/helius.ts

@@ -1,7 +1,7 @@
 import { Transaction } from "@solana/web3.js"
 import axios from "axios"
 
-export const HELIUS_JITO_TIP_ACCOUNTS = [
+export const HELIUS_TIP_ACCOUNTS = [
     "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
     "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
     "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
@@ -14,9 +14,13 @@ export const HELIUS_JITO_TIP_ACCOUNTS = [
     "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
 ]
 
-export const sendTxWithHelius = async (signedTransaction: Transaction, send_jito:boolean=true): Promise<string> => {
-    let url = 'http://tyo-sender.helius-rpc.com/fast'
-    if(!send_jito) {
+/**
+ * Jito + SWQOS
+ */
+export const sendTxWithHelius = async (signedTransaction: Transaction, tip_helius: boolean): Promise<string> => {
+    let url = process.env.HELIUS_SEND_TX_URL || 'http://tyo-sender.helius-rpc.com/fast'
+    
+    if (!tip_helius) {
         url = url + "?swqos_only=true"
     }
     const response = await axios.post<{ result: string }>(url, {
@@ -32,7 +36,13 @@ export const sendTxWithHelius = async (signedTransaction: Transaction, send_jito
             }
         ]
     })
-    console.dir(response.data, { depth: null })
-    
+
+    // {
+    //     jsonrpc: '2.0',
+    //     id: '1764747765426',
+    //     result: '49b7P6SQ5rEDTwGbZs3xAt1QVmx3asSh74TSzoKd9Hsi7owc4KxGadUpyHrSoQDVABUzHqjauTab4EVmf5C2VhvP'
+    // }
+    // console.dir(response.data, { depth: null })
+
     return response.data.result;
 }

package/src/trade/send/jito.ts

@@ -1,35 +1,67 @@
-// import { TradeContext } from "@clonegod/ttd-core/dist";
-// import { ComputeBudgetProgram, Keypair, LAMPORTS_PER_SOL, PublicKey, SystemProgram, Transaction, TransactionInstruction } from "@solana/web3.js";
-// import axios from "axios";
-
-// export class JitoUtils {
-//     public jitoTipAccounts: string[] = []
-
-//     constructor() {
-//         this.init();
-//     }
-
-//     async init(): Promise<void> {
-//         return this.fetchJitoTipAccounts().then((accounts) => {
-//             this.jitoTipAccounts = accounts;
-//             console.log(`fetchJitoTipAccounts success: ${accounts.length} accounts`, accounts)
-//         });
-//     }
-
-//     async fetchJitoTipAccounts(): Promise<string[]> {
-//         const response = await axios.post<{ result: string[] }>('https://mainnet.block-engine.jito.wtf/api/v1/getTipAccounts', {
-//             jsonrpc: '2.0',
-//             id: 1,
-//             method: 'getTipAccounts',
-//             params: []
-//         })
-//         return response.data.result;
-//     }
-
-//     getRandomJitoTipAccount(): string {
-//         if(this.jitoTipAccounts.length === 0) {
-//             throw new Error('jitoTipAccounts is empty');
-//         }
-//         return this.jitoTipAccounts[Math.floor(Math.random() * this.jitoTipAccounts.length)];
-//     }
-// }
+import { Transaction } from "@solana/web3.js";
+import axios from "axios";
+
+export const JITO_TIP_ACCOUNTS = [
+    "DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh",
+    "DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL",
+    "3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT",
+    "96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5",
+    "ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt",
+    "Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY",
+    "ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49",
+    "HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe"
+]
+
+export class JitoUtils {
+    static jitoTipAccounts: string[] = []
+
+    static async init(): Promise<void> {
+        return JitoUtils.fetchJitoTipAccounts().then((accounts) => {
+            JitoUtils.jitoTipAccounts = accounts;
+            console.log(`fetchJitoTipAccounts success: ${accounts.length} accounts`, accounts)
+        });
+    }
+
+    static async fetchJitoTipAccounts(): Promise<string[]> {
+        const response = await axios.post<{ result: string[] }>('https://mainnet.block-engine.jito.wtf/api/v1/getTipAccounts', {
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'getTipAccounts',
+            params: []
+        })
+        return response.data.result;
+    }
+}
+
+
+export const getJitoTipAccount = (): string => {
+    let jito_tip_accounts = JitoUtils.jitoTipAccounts
+    if (JitoUtils.jitoTipAccounts.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 (signedTransactions: Transaction[]): Promise<string> => {
+    let url = process.env.JITO_SEND_BUNDLE_URL || 'https://tokyo.mainnet.block-engine.jito.wtf/api/v1/bundles'
+
+    const response = await axios.post<{ result: string }>(url, {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'sendBundle',
+        params: [
+            signedTransactions.map(tx => Buffer.from(tx.serialize()).toString('base64')),
+            {
+                "encoding": "base64"
+            }
+        ]
+    })
+    console.dir(response.data, { depth: null })
+    
+    return response.data.result;
+}
+

package/src/trade/send/send_tx.ts

@@ -1,34 +1,27 @@
-import { AppConfig, log_error, log_info, TradeContext } from '@clonegod/ttd-core/dist';
-import { Connection, Keypair, Transaction, TransactionInstruction } from '@solana/web3.js';
+import { Transaction } from '@solana/web3.js';
 import { sendTxWithHelius } from './helius';
+import { sendBundleWithJito } from './jito';
 
 
 /**
- * Solana 交易发送器（参考 BSC 的多渠道并行发送设计）
- * 
- * 设计思路对齐 BSC：
- * - 交易构造由具体 DEX Trade 类完成，只返回 swap 指令
- * - buildMainTx 负责构建主交易（所有渠道共用，只构建一次）
- * - buildTipTx 负责构建 tip 交易（渠道特定，动态构建）
- * - TransactionSender 负责多渠道并行发送（RPC / Helius / Jito）
+ * Solana 交易发送器
  */
 export class TransactionSender {
 
     constructor() {
     }
 
-    async sendTransaction(singedTransactions: Transaction[]): Promise<string> {
+    async sendTransaction(singedTransactions: Transaction[], tip_helius:boolean): Promise<string> {
         if(singedTransactions.length === 1) {
-            return await sendTxWithHelius(singedTransactions[0])
+            return await sendTxWithHelius(singedTransactions[0], tip_helius)
         } else {
             return await this.sendBundle(singedTransactions)
         }
     }
 
     async sendBundle(signedTransactions: Transaction[]): Promise<string> {
-        throw new Error('not implemented')
+        return await sendBundleWithJito(signedTransactions)
     }
 
-
 }
 

package/src/trade/tx_builder.ts

@@ -3,7 +3,8 @@ import { ComputeBudgetProgram, Connection, Keypair, LAMPORTS_PER_SOL, PublicKey,
 import { LAMPORTS_PER_MICRO_LAMPORTS } from "../common";
 import { SolanaBlockMetaUpdateEvent } from "../types";
 import { SolanaTradeAppConfig } from "./SolanaTradeAppConfig";
-import { HELIUS_JITO_TIP_ACCOUNTS } from "./send/helius";
+import { HELIUS_TIP_ACCOUNTS } from "./send/helius";
+import { getJitoTipAccount } from "./send/jito";
 
 
 export class SolTransactionBuilder {
@@ -34,13 +35,9 @@ export class SolTransactionBuilder {
         // console.log(`handleBlockUpdateEvent, blockHeight: ${blockHeight}, blockHash: ${blockHash}`)
     }
 
-    execute(context: TradeContext): Promise<string> {
-        throw new Error('not implemented!!!')
-    }
-
 
     // pre-instructions
-    getPreInstructions(context: TradeContext): TransactionInstruction[] {
+    private getPreInstructions(context: TradeContext): TransactionInstruction[] {
         const cu_limit = context.pool_info.cu_limit || 600000
         const sol_priority_fee_lamports = context.trade_runtime.settings.strategy.sol_priority_fee
         const priorityFeeMicroLamports = Math.floor((sol_priority_fee_lamports * LAMPORTS_PER_MICRO_LAMPORTS) / cu_limit)
@@ -61,12 +58,12 @@ export class SolTransactionBuilder {
 
     
     // post-instructions
-    getPostInstructions(context: TradeContext): TransactionInstruction[] {
+    private getPostInstructions(context: TradeContext): TransactionInstruction[] {
         return []
     }
 
 
-    buildTransactionForSwap(context: TradeContext, swapInstructions: TransactionInstruction[], send_jito: boolean=true): Transaction {
+    buildTransactionForSwap(context: TradeContext, swapInstructions: TransactionInstruction[], tip_helius:boolean): Transaction {
         const max_block_offset = context.trade_runtime.settings.strategy.max_block_offset
         // console.log(`buildTransactionForSwap, max_block_offset: ${max_block_offset}`)
 
@@ -80,8 +77,8 @@ export class SolTransactionBuilder {
         swapTx.lastValidBlockHeight = this.recentBlockheight + max_block_offset
         swapTx.feePayer = this.keypair.publicKey
 
-        if(send_jito) {
-            let jitoTipInstruction = this.getHeliusJitoTipInstruction(context)
+        if(tip_helius) {
+            let jitoTipInstruction = this.getHeliusTipInstruction(context)
             swapTx.instructions.push(jitoTipInstruction)
         }
 
@@ -90,37 +87,47 @@ export class SolTransactionBuilder {
         return swapTx
     }
 
-    getHeliusJitoTipInstruction(context: TradeContext): TransactionInstruction {
-        let tip_lamports = Math.max(context.trade_runtime.settings.strategy.sol_tip_fee, 0.0002 * LAMPORTS_PER_SOL)
+    private getHeliusTipInstruction(context: TradeContext): TransactionInstruction {
+        // Requires minimum 0.0002 SOL tip. (Helius)
+        // transaction must send a tip of at least 5000 lamports to one of the following Helius wallets: [xxx, ...]
+        let tip_lamports = Math.min(context.trade_runtime.settings.strategy.sol_tip_fee, 0.0002 * LAMPORTS_PER_SOL)
         return SystemProgram.transfer({
             fromPubkey: this.keypair.publicKey,
-            toPubkey: new PublicKey(HELIUS_JITO_TIP_ACCOUNTS[Math.floor(Math.random() * HELIUS_JITO_TIP_ACCOUNTS.length)]),
+            toPubkey: new PublicKey(HELIUS_TIP_ACCOUNTS[Math.floor(Math.random() * HELIUS_TIP_ACCOUNTS.length)]),
             lamports: tip_lamports,
         })
     }
 
-    buildTransactionForTip(context: TradeContext, tipAccount: string, tipAmount: number, tipPayer: Keypair=undefined): Transaction {
+
+
+    /**
+     * build transaction for tip jito
+     */
+    buildTransactionForTipJito(context: TradeContext, tipPayer: Keypair=undefined): Transaction {
         const max_block_offset = context.trade_runtime.settings.strategy.max_block_offset
 
         if(!tipPayer) {
             tipPayer = this.keypair
         }
+
+        let tipAccount = getJitoTipAccount()
+        let tipAmount = Math.min(context.trade_runtime.settings.strategy.sol_tip_fee, 0.0002 * LAMPORTS_PER_SOL)
         
-        const tipTx = new Transaction();
-        tipTx.add(
+        const jitoTipTx = new Transaction();
+        jitoTipTx.add(
             SystemProgram.transfer({
                 fromPubkey: tipPayer.publicKey,
                 toPubkey: new PublicKey(tipAccount),
                 lamports: tipAmount,
             }),
         );
-        tipTx.recentBlockhash = this.recentBlockhash
-        tipTx.lastValidBlockHeight = this.recentBlockheight + max_block_offset
-        tipTx.feePayer = tipPayer.publicKey;
+        jitoTipTx.recentBlockhash = this.recentBlockhash
+        jitoTipTx.lastValidBlockHeight = this.recentBlockheight + max_block_offset
+        jitoTipTx.feePayer = tipPayer.publicKey;
 
-        tipTx.sign(tipPayer)
+        jitoTipTx.sign(tipPayer)
 
-        return tipTx
+        return jitoTipTx
     }
 
 }