Merge branch 'release/0.1.9'

Author: mkdir700

app/tg-bot/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "solbot-tgbot"
-version = "0.1.8"
+version = "0.1.9"
 description = "Telegram bot for Solana trading"
 authors = [
     { name = "mkdir700", email = "mkdir700@gmail.com" },

app/trading/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "solbot-trading"
-version = "0.1.8"
+version = "0.1.9"
 description = "Trading for Solana"
 authors = [
     { name = "mkdir700", email = "mkdir700@gmail.com" },

app/trading/trading/executor.py

@@ -21,9 +21,8 @@
 class TradingExecutor:
     def __init__(self, client: AsyncClient):
         self._rpc_client = client
-        self._jito_client = JitoClient()
-        self._raydium_api = RaydiumAPI()
         self._launch_cache = LaunchCache()
+        self._trading_service = TradingService(self._rpc_client)
 
     @provide_session
     async def __get_keypair(self, pubkey: str, *, session=NEW_ASYNC_SESSION) -> Keypair:
@@ -91,19 +90,14 @@ async def exec(self, swap_event: SwapEvent):
         # NOTE: 测试下来不是很理想，暂时使用备选方案
         elif swap_event.program_id == RAY_V4_PROGRAM_ID:
             logger.info("Program ID is RayV4")
-            trade_route = TradingRoute.GMGN
+            trade_route = TradingRoute.DEX
         elif program_id is None or program_id == RAY_V4_PROGRAM_ID:
             logger.warning("Program ID is Unknown, So We use thrid party to trade")
-            trade_route = TradingRoute.GMGN
+            trade_route = TradingRoute.DEX
         else:
             raise ValueError(f"Program ID is not supported, {swap_event.program_id}")
 
-        sig = await TradingService.create(
-            trade_route,
-            self._rpc_client,
-            use_jito=settings.trading.use_jito,
-            jito_client=self._jito_client,
-        ).swap(
+        sig = await self._trading_service.use_route(trade_route).swap(
             keypair,
             token_address,
             swap_event.ui_amount,

app/trading/trading/main.py

@@ -1,15 +1,14 @@
 import asyncio
 import time
-import httpx
 from typing import Optional
 
 import backoff
-
+import httpx
 from common.cp.swap_event import SwapEventConsumer
 from common.cp.swap_result import SwapResultProducer
 from common.log import logger
-from common.types.swap import SwapEvent, SwapResult
 from common.prestart import pre_start
+from common.types.swap import SwapEvent, SwapResult
 from db.redis import RedisClient
 from trading.copytrade import CopyTradeProcessor
 from trading.executor import TradingExecutor
@@ -47,8 +46,6 @@ async def _process_single_swap_event(self, swap_event: SwapEvent):
         """处理单个交易事件的核心逻辑"""
         async with self.semaphore:
             logger.info(f"Processing swap event: {swap_event}")
-            sig = None
-            swap_result = None
 
             try:
                 sig = await self._execute_swap(swap_event)

app/trading/trading/transaction/__init__.py

@@ -1,13 +1,12 @@
 from trading.transaction.base import TransactionSender
 from trading.transaction.builders.base import TransactionBuilder
-from trading.transaction.factory import TransactionFactory, TradingService
+from trading.transaction.factory import TradingService
 from trading.transaction.protocol import TradingRoute
 from trading.transaction.sender import DefaultTransactionSender, JitoTransactionSender
 
 __all__ = [
     "TransactionBuilder",
     "TransactionSender",
-    "TransactionFactory",
     "TradingService",
     "TradingRoute",
     "DefaultTransactionSender",

app/trading/trading/transaction/base.py

@@ -1,31 +1,27 @@
 from abc import ABC, abstractmethod
-from typing import Optional
 
 from solana.rpc.async_api import AsyncClient
-from solana.rpc.types import TxOpts
-from solders.signature import Signature
-from solders.transaction import VersionedTransaction
-
-from common.utils.jito import JitoClient
+from solders.signature import Signature  # type: ignore
+from solders.transaction import VersionedTransaction  # type: ignore
 
 
 class TransactionSender(ABC):
     """交易发送器的抽象基类"""
 
-    def __init__(self, client: AsyncClient | JitoClient):
-        self.client = client
+    def __init__(self, rpc_client: AsyncClient):
+        self.rpc_client = rpc_client
 
     @abstractmethod
     async def send_transaction(
         self,
         transaction: VersionedTransaction,
-        opts: Optional[TxOpts] = None,
+        **kwargs,
     ) -> Signature:
         """发送交易
 
         Args:
             transaction (VersionedTransaction): 要发送的交易
-            opts (Optional[TxOpts], optional): 交易选项. Defaults to None.
+            **kwargs: 可选的关键字参数
 
         Returns:
             Signature: 交易签名

app/trading/trading/transaction/builders/gmgn.py

@@ -1,12 +1,11 @@
-import httpx
+from cache.token_info import TokenInfoCache
+from common.config import settings
+from common.constants import SOL_DECIMAL, WSOL
+from common.utils.gmgn import GmgnAPI
 from solana.rpc.async_api import AsyncClient
 from solders.keypair import Keypair  # type: ignore
 from solders.transaction import VersionedTransaction  # type: ignore
 
-from cache.token_info import TokenInfoCache
-from common.config import settings
-from common.constants import SOL_DECIMAL, WSOL
-from trading.exceptions import NoRouteFound
 from trading.swap import SwapDirection, SwapInType
 from trading.tx import sign_transaction_from_raw
 
@@ -17,10 +16,9 @@ class GMGNTransactionBuilder(TransactionBuilder):
     """GMGN 交易构建器"""
 
     def __init__(self, rpc_client: AsyncClient) -> None:
-        self.client = httpx.AsyncClient(base_url="https://gmgn.ai")
-        self.api_path = "/defi/router/v1/sol/tx/get_swap_route"
-        self.rpc_client = rpc_client
+        super().__init__(rpc_client=rpc_client)
         self.token_info_cache = TokenInfoCache()
+        self.gmgn_client = GmgnAPI()
 
     async def build_swap_transaction(
         self,
@@ -73,30 +71,14 @@ async def build_swap_transaction(
             fee = priority_fee
 
         slippage = slippage_bps / 100
-        params = {
-            "token_in_address": token_in,
-            "token_out_address": token_out,
-            "in_amount": amount,
-            "from_address": keypair.pubkey().__str__(),
-            "slippage": slippage,
-            "swap_mode": swap_mode,
-            "fee": fee,
-        }
-
-        # TODO: 获取报价解耦
-        resp = await self.client.get(self.api_path, params=params)
-        resp.raise_for_status()
-
-        js = resp.json()
-        if js["code"] != 0:
-            msg = js["msg"]
-            if "no route" in msg:
-                raise NoRouteFound(msg)
-            raise Exception("Error: {}, Argument: {}".format(js["msg"], params))
-
-        data = js["data"]
-        raw_tx = data["raw_tx"]
-        swap_tx = raw_tx["swapTransaction"]
-
+        swap_tx = await self.gmgn_client.get_swap_transaction(
+            token_in_address=token_in,
+            token_out_address=token_out,
+            in_amount=amount,
+            from_address=keypair.pubkey().__str__(),
+            slippage=slippage,
+            swap_mode=swap_mode,
+            fee=fee,
+        )
         signed_tx = await sign_transaction_from_raw(swap_tx, keypair)
         return signed_tx

app/trading/trading/transaction/builders/jupiter.py

@@ -0,0 +1,79 @@
+from cache.token_info import TokenInfoCache
+from common.constants import SOL_DECIMAL, WSOL
+from common.utils.jupiter import JupiterAPI
+from solana.rpc.async_api import AsyncClient
+from solders.keypair import Keypair  # type: ignore
+from solders.transaction import VersionedTransaction  # type: ignore
+
+from trading.swap import SwapDirection, SwapInType
+from trading.tx import sign_transaction_from_raw
+
+from .base import TransactionBuilder
+
+
+class JupiterTransactionBuilder(TransactionBuilder):
+    """Jupiter 交易构建器"""
+
+    def __init__(self, rpc_client: AsyncClient) -> None:
+        super().__init__(rpc_client=rpc_client)
+        self.token_info_cache = TokenInfoCache()
+        self.jupiter_client = JupiterAPI()
+
+    async def build_swap_transaction(
+        self,
+        keypair: Keypair,
+        token_address: str,
+        ui_amount: float,
+        swap_direction: SwapDirection,
+        slippage_bps: int,
+        in_type: SwapInType | None = None,
+        use_jito: bool = False,
+        priority_fee: float | None = None,
+    ) -> VersionedTransaction:
+        """Build swap transaction with GMGN API.
+
+        Args:
+            token_address (str): token address
+            amount_in (float): amount in
+            swap_direction (SwapDirection): swap direction
+            slippage (int): slippage, percentage
+            in_type (SwapInType | None, optional): in type. Defaults to None.
+            use_jto (bool, optional): use jto. Defaults to False.
+            priority_fee (float | None, optional): priority fee. Defaults to None.
+
+        Returns:
+            VersionedTransaction: The built transaction ready to be signed and sent
+        """
+        if swap_direction == "sell" and in_type is None:
+            raise ValueError("in_type must be specified when selling")
+
+        if swap_direction == SwapDirection.Buy:
+            token_in = str(WSOL)
+            token_out = token_address
+            amount = int(ui_amount * SOL_DECIMAL)
+        elif swap_direction == SwapDirection.Sell:
+            token_info = await self.token_info_cache.get(token_address)
+            if token_info is None:
+                raise ValueError("Token info not found")
+            decimals = token_info.decimals
+            token_in = token_address
+            token_out = str(WSOL)
+            amount = int(ui_amount * 10**decimals)
+        else:
+            raise ValueError("swap_direction must be buy or sell")
+
+        if use_jito and priority_fee is None:
+            raise ValueError("priority_fee must be specified when using jito")
+
+        swap_tx_response = await self.jupiter_client.get_swap_transaction(
+            input_mint=token_in,
+            output_mint=token_out,
+            user_publickey=str(keypair.pubkey()),
+            amount=amount,
+            slippage_bps=slippage_bps,
+            use_jito=use_jito,
+            jito_tip_lamports=int(priority_fee * SOL_DECIMAL) if priority_fee else None,
+        )
+        swap_tx = swap_tx_response["swapTransaction"]
+        signed_tx = await sign_transaction_from_raw(swap_tx, keypair)
+        return signed_tx