cherry-shared2 0.1.26__py3-none-any.whl

cherry_shared/InfoService.py

@@ -0,0 +1,369 @@
+import json
+import logging
+from typing import Any, Dict, Literal, Optional
+import aiohttp
+from cherry_shared.launchpads import LaunchPad
+from cherry_shared.types.dexscreener import Pair
+from cherry_shared.types.launchpad import LaunchpadToken
+
+
+class InfoService:
+
+    def __init__(self, info_url: str, helper_url: str, logger: logging.Logger = None):
+        self.info_url = info_url
+        self.helper_url = helper_url
+        if logger is None:
+            self._logger = logging.getLogger(__name__)
+        else:
+            self._logger = logger
+
+    async def process_request(
+        self,
+        url: str,
+        body: Dict[str, Any] = None,
+        method: str = "GET",
+        query: Dict[str, str] = None,
+        headers: Dict[str, str] = None,
+        timeout: int = 60,
+    ):
+        if headers is None:
+            headers = {"Content-Type": "application/json"}
+        # Define a custom timeout
+        custom_timeout = aiohttp.ClientTimeout(total=timeout)
+
+        async with aiohttp.ClientSession(
+            headers=headers, timeout=custom_timeout
+        ) as session:
+            try:
+                if method == "GET":
+                    async with session.get(
+                        url, params=query, data=json.dumps(body) if body else None
+                    ) as resp:
+                        if resp.status >= 400:
+                            return False, resp.reason
+                        if "application/json" in resp.headers.get("Content-Type", ""):
+                            res = await resp.json()
+                        else:
+                            res = await resp.text()
+                            return (
+                                False,
+                                f"Unexpected Content-Type: {resp.headers.get('Content-Type')}, Response: {res}",
+                            )
+                elif method == "POST":
+                    async with session.post(url, data=json.dumps(body)) as resp:
+                        if resp.status >= 400:
+                            return False, resp.reason
+                        if "application/json" in resp.headers.get("Content-Type", ""):
+                            res = await resp.json()
+                        else:
+                            res = await resp.text()
+                            return (
+                                False,
+                                f"Unexpected Content-Type: {resp.headers.get('Content-Type')}, Response: {res}",
+                            )
+
+                return True, res
+            except Exception as e:
+                self._logger.error(f"Error in InfoService.process_request(): {e}")
+                return False, "Exception: " + str(e)
+
+    async def search_address(self, address: str):
+        url = f"{self.info_url}/info/{address}"
+        success, data = await self.process_request(url)
+        if success:
+            return [Pair.from_dexsc_dict(item) for item in data["data"][:10]]
+
+    async def get_address_type(self, address: str):
+        url = f"{self.info_url}/address"
+        body = {"address": address}
+        success, res = await self.process_request(url, body)
+        if success:
+            return res["data"]
+
+    async def get_pair_by_pair_address(self, address: str, chainId: str):
+        url = f"{self.info_url}/info/pair"
+        success, res = await self.process_request(
+            url, {"address": address, "chainId": chainId}, "POST"
+        )
+
+        if not success:
+            self._logger.error(res)
+            return None
+        return Pair.from_dexsc_dict(res["data"])
+
+    async def get_chains_data(self):
+        url = f"{self.info_url}/chains"
+        success, data = await self.process_request(url)
+        if success:
+            return data
+
+    async def get_total_supply(self, chain: str, address: str):
+        url = self.helper_url + "/totalsupply"
+        body = {"chain": chain, "address": address}
+        success, data = await self.process_request(url, body, "POST")
+        if success:
+            return data["supply"], data["decimals"]
+        return None, None
+
+    async def get_trending(self):
+        url = self.helper_url + "/trending"
+        success, data = await self.process_request(url)
+        if success:
+            return data
+        return None
+
+    async def send_confirm_req(
+        self, pair_address: str, contract_address: str, chain_id: str, chat_id: int
+    ):
+        url = self.helper_url + "/confirm"
+        self._logger.debug(f"{pair_address}, {chain_id}, {chat_id}")
+        body = {
+            "pairAddress": pair_address,
+            "tokenAddress": contract_address,
+            "chainId": chain_id,
+            "chatId": chat_id,
+        }
+        self._logger.debug(f"send_confirm_req: {body}")
+        success, data = await self.process_request(url, body, "POST")
+        if not success:
+            self._logger.error(f"failed to send confirm req: {data}")
+
+    async def send_delete_req(self, tokenAddress: str, chat_id: int):
+        url = self.helper_url + "/delete"
+        body = {
+            "tokenAddress": tokenAddress,
+            "chatId": chat_id,
+        }
+        success, data = await self.process_request(url, body, "POST")
+        if not success:
+            self._logger.error(f"failed delete token req: {data}")
+
+    async def send_update_supply(self, tokenAddress: str, chat_id: int, supply: int):
+        self._logger.debug(f"{tokenAddress}, {chat_id}, {supply}")
+        url = self.helper_url + "/updatesupply"
+        body = {
+            "address": tokenAddress,
+            "chatId": chat_id,
+            "supply": supply,
+        }
+        success, data = await self.process_request(url, body, "POST")
+        if not success:
+            self._logger.error(f"failed update supply req: {data}")
+
+    async def generate_wallet(self, wallet_type: str):
+        wallet_endpoints = {
+            "solana": "/generatesolanawallet",
+            "tron": "/generatetronwallet",
+            "sui": "/generatesuiawallet",
+        }
+
+        if wallet_type not in wallet_endpoints:
+            self._logger.error(f"wallet endpoint not provided: {wallet_type}")
+            return
+
+        url = self.helper_url + wallet_endpoints[wallet_type]
+        success, data = await self.process_request(url)
+
+        if not success:
+            self._logger.error(f"Failed {wallet_type} wallet request: {data}")
+            return
+        self._logger.debug(f"generated new wallet {data['publicKey'][:10]}")
+        return data["publicKey"], data["privateKey"]
+
+    async def get_balance(self, wallet_address: str, chain: str):
+        url = self.helper_url + "/balance"
+        success, data = await self.process_request(
+            url, query={"tokenAddress": wallet_address, "chain": chain}
+        )
+        if not success:
+            self._logger.error(f"failed to get balance: {data}")
+            return None
+        return float(data["balance"])
+
+    async def buyNburn(
+        self,
+        raid_id: int,
+        chat_id: int,
+        amount: float,
+        token_address: str,
+        pair_address: str,
+        chain: str,
+        pk: str,
+    ):
+        url = self.helper_url + "/burn"
+        body = {
+            "raidId": raid_id,
+            "chatId": chat_id,
+            "amount": amount,
+            "tokenAddress": token_address,
+            "pairAddress": pair_address,
+            "chain": chain,
+            "privateKey": pk,
+        }
+        success, data = await self.process_request(url, body, "POST")
+        if not success:
+            self._logger.error(f"failed to send confirm req: {data}")
+            return False, data
+
+        status: bool = data["status"]
+        self._logger.debug(f"buyNburn status = {status}")
+        return status, None
+
+    async def check_status(self, raid_id: int):
+        try:
+            url = self.helper_url + f"/status?raidId={raid_id}"
+            success, data = await self.process_request(url)
+            if not success:
+                self._logger.error(f"failed to send confirm req: {data}")
+                return "error", data
+            res = data["status"], (
+                data["buyTx"],
+                data["burnTx"],
+                data["finalBountyAmount"],
+            )
+            return res
+        except Exception as e:
+            self._logger.error(
+                f"Error in InfoService.check_status(): {e}", exc_info=True
+            )
+            return "error", str(e)
+
+    async def withdraw(self, chain: str, toAddress: str, userId: int):
+        url = self.helper_url + "/withdraw"
+        query = {"chain": chain, "toAddress": toAddress, "userId": userId}
+        success, res = await self.process_request(url, query=query)
+        if not success:
+            self._logger.error(f"Info Withdraw: {res}")
+            return False, res
+        tx_hash = res["txHash"]
+        return True, tx_hash
+
+    async def validate_purchase(
+        self,
+        user_id: int,
+        value: float,
+        chain: str,
+        promo_code: str = None,
+        payout_value: float = None,
+        token_id: int = None,
+        trendingId: int = None,
+        volume_bot=0,
+        status: Literal["normal", "volume", "holder"] = "normal",
+        hours=None,
+        base_amount: float = 0.01,
+        **kwargs,
+    ):
+        url = self.helper_url + "/trendingslot/verify"
+        body = {
+            "chain": chain,
+            "value": value,
+            "userId": user_id,
+            "promoCode": promo_code,
+            "payoutValue": payout_value,
+            "tokenId": token_id,
+            "trendingId": trendingId,
+            "volumeBot": 1 if status == "holder" else volume_bot,
+            "status": status,
+            "hours": hours,
+            "baseAmount": base_amount,
+        }
+
+        # Add any additional key-value arguments to the body
+        body.update(kwargs)
+
+        success, res = await self.process_request(url, body, "POST")
+        if not success:
+            self._logger.error(f"Info validate_purchase: {res}")
+            return -1, res
+
+        code = int(res["code"])
+        message = res["message"] if code == 0 else res["error"]
+
+        return code, message
+
+    async def get_token_info(self, address: str, chain: str):
+        url = self.info_url + "/info/tokeninfo"
+        body = {"address": address, "chain": chain}
+        success, res = await self.process_request(url, body=body, method="POST")
+        if not success:
+            self._logger.error(f"get_token_info: {res}")
+            return None
+
+        code = int(res["code"])
+        if code == 0:
+            self._logger.debug(f"get_token_info: {res['data']}")
+            return res["data"]
+
+    async def get_launchpad_data(self, launchpad: LaunchPad, address: str):
+        url = self.info_url + f"/{launchpad.info_route}"
+        body = {"address": address, "chatId": 0}
+        success, res = await self.process_request(url, body=body, method="POST")
+        if not success:
+            self._logger.error(f"get {launchpad.name} info: {res}")
+            return None
+
+        code = int(res["code"])
+        self._logger.debug(f"get_launchpad_data: {res['data']}")
+        if code == 0:
+            return LaunchpadToken.create_token_info(res["data"])
+
+    async def get_fees(self, address: str):
+        try:
+            url = self.helper_url + f"/getFees"
+            body = {"address": address}
+            success, res = await self.process_request(url, body=body, method="POST")
+            if not success:
+                self._logger.error(f"get_fees info for address {address}: {res}")
+                return None
+            self._logger.debug(f"get_fees: {res}")
+            return round(float(res.get("fee", 1)), 2)
+        except Exception as e:
+            self._logger.error(f"Error in InfoService.get_fees(): {e}", exc_info=True)
+            return 1
+
+    async def send_message(self, chat_id: int, message: str, thread_id: str = None):
+        url = self.helper_url + "/sendtrendingmessage"
+        body = {
+            "chat_id": chat_id,
+            "text": message,
+            "thread_id": thread_id,
+        }
+        success, res = await self.process_request(url, body=body, method="POST")
+        if not success:
+            self._logger.error(f"send_message: {res}")
+            return False, res
+        return True, res
+
+    async def edit_message(
+        self, chat_id: int, message_id: int, message: str, thread_id: str = None
+    ):
+        url = self.helper_url + "/sendtrendingmessage"
+        body = {
+            "chat_id": chat_id,
+            "msg_id": message_id,
+            "text": message,
+            "thread_id": thread_id,
+        }
+
+        success, res = await self.process_request(url, body=body, method="POST")
+        if not success:
+            self._logger.error(f"edit_message: {res}")
+            return False, res
+        return True, res
+
+    async def check_rate_limit(
+        self,
+        chat_id: Optional[int] = None,
+        priority: Literal["high", "normal", "low"] = "normal",
+    ):
+        url = self.helper_url + "/check-rate-limit"
+        body = {
+            "chat_id": chat_id,
+            "priority": priority,
+        }
+        success, res = await self.process_request(url, body=body, method="POST")
+        if not success:
+            self._logger.error(f"check_rate_limit: {res}")
+            return 0
+        delay = int(res.get("delay_ms", 0)) / 1000.0
+        return delay

cherry_shared/__init__.py

@@ -0,0 +1,5 @@
+from .blockchains import Blockchains, BlockchainId, ChainType
+from .bot_strings import BotStrings
+from .constants import Constants
+from .emojis import Emojis, state_emoji
+from .launchpads import LaunchPads, LaunchPadId, LaunchPad

cherry_shared/blockchains.py

@@ -0,0 +1,265 @@
+from typing import Dict, List, Set
+from cherry_shared.types.blockchain import Blockchain, SupportedFeatures
+from functools import lru_cache
+from enum import Enum
+
+
+class ChainType(Enum):
+    EVM = "evm"
+    SOLANA = "solana"
+    TRON = "tron"
+    TON = "ton"
+    SUI = "sui"
+
+
+class BlockchainId:
+    SOL = "solana"
+    ETH = "ethereum"
+    BSC = "bsc"
+    TRX = "tron"
+    BASE = "base"
+    SUI = "sui"
+    MANTA = "manta"
+    MATIC = "polygon"
+    XPL = "plasma"
+
+
+class Blockchains:
+    SOL = Blockchain(
+        BlockchainId.SOL,
+        "SOL",
+        "Solana",
+        "SOL",
+        "https://solscan.io/token",
+        False,
+        {
+            3: {3: 0, 6: 0, 12: 6, 24: 9},
+            10: {3: 1.6 , 6: 2.5, 12: 4, 24: 7},
+        },
+        ["SOL", "USDC"],
+        {
+            150: 0.2,
+            300: 0.4,
+        },
+        SupportedFeatures(custom_token=True, wallet=True, payment=True),
+        0.1,
+        extras={
+            "volume_price": {
+             50000: 3.2,
+             100_000: 5.8,
+             250_000: 13.0,
+             500_000: 24.6,
+             1_000_000: 45.8,
+             5_000_000: 214.6,
+            },
+            "holders_price": {
+                1000: 2.2,
+                2500: 5.5,
+                5000: 11,
+                10000: 22,
+                25000: 55,
+                100_000: 220,
+            },
+            "boost_price": {1000: 0.4, 2000: 0.7, 4000: 1.3, 8000: 2.5},
+        },
+    )
+
+    ETH = Blockchain(
+        BlockchainId.ETH,
+        "ETH",
+        "Ethereum",
+        "ETH",
+        "https://etherscan.io/token",
+        True,
+        {
+            3: {3: 0.2, 6: 0.4, 12: 0.6, 24: 0.9},
+            10: {3: 0.1, 6: 0.2, 12: 0.4, 24: 0.6},
+        },
+        ["WETH", "USDT", "USDC"],
+        {150: 0.02, 300: 0.04, 950: 0.1, 2500: 0.2},
+        SupportedFeatures(custom_token=True, wallet=True, payment=True),
+        0.05,
+    )
+
+    BSC = Blockchain(
+        BlockchainId.BSC,
+        "BSC",
+        "Binance Smart Chain",
+        "BNB",
+        "https://bscscan.com/token",
+        True,
+        {
+            3: {3: 0.7, 6: 1.2, 12: 2.0, 24: 3.5},
+            10: {3: 0.6, 6: 0.8, 12: 1.5, 24: 2.5},
+        },
+        ["WBNB", "USDT", "USDC"],
+        {150: 0.1, 300: 0.2, 950: 0.5, 2500: 1},
+        SupportedFeatures(custom_token=False, wallet=True, payment=True),
+        0.1,
+        extras={
+            "boost_price": {1000: 0.7, 2000: 1.4, 4000: 2.5, 8000: 4.6},
+        },
+    )
+
+    TRX = Blockchain(
+        BlockchainId.TRX,
+        "TRX",
+        "Tron",
+        "TRX",
+        "https://tronscan.org/#/token20",
+        False,
+        {
+            3: {3: 1260, 6: 2270, 12: 3530, 24: 6050},
+            10: {3: 1000, 6: 1770, 12: 3020, 24: 4540},
+        },
+        ["WTRX", "USDT", "USDC"],
+        {150: 0.02, 300: 0.04, 950: 0.1, 2500: 0.2},
+        SupportedFeatures(custom_token=False, wallet=True, payment=True),
+        10,
+    )
+
+    BASE = Blockchain(
+        BlockchainId.BASE,
+        "BASE",
+        "Base",
+        "ETH",
+        "https://basescan.org/token",
+        True,
+        {
+            3: {3: 0.2, 6: 0.4, 12: 0.6, 24: 0.9},
+            10: {3: 0.1, 6: 0.2, 12: 0.4, 24: 0.6},
+        },
+        ["WETH", "USDT", "USDC"],
+        {150: 0.02, 300: 0.04, 950: 0.1, 2500: 0.2},
+        SupportedFeatures(custom_token=False, wallet=True, payment=True),
+        0.1,
+    )
+
+    MATIC = Blockchain(
+        BlockchainId.MATIC,
+        "POL",
+        "Polygon",
+        "POL",
+        "https://polygonscan.com/token",
+        True,
+        {
+            3: {3: 800, 6: 1330, 12: 2100, 24: 3430},
+            10: {3: 520, 6: 800, 12: 1330, 24: 2100},
+        },
+        ["WPOL", "USDT", "USDC"],
+        {150: 0.02, 300: 0.04, 950: 0.1, 2500: 0.2},
+        SupportedFeatures(custom_token=False, wallet=True, payment=True),
+        10,
+    )
+
+    MANTA = Blockchain(
+        BlockchainId.MANTA,
+        "MANTA",
+        "MANTA",
+        "ETH",
+        "https://pacific-explorer.manta.network/token",
+        True,
+        {
+            3: {3: 0.2, 6: 0.4, 12: 0.6, 24: 0.9},
+            10: {3: 0.1, 6: 0.2, 12: 0.4, 24: 0.6},
+        },
+        ["WETH", "USDT", "USDC", "MANTA"],
+        {150: 0.02, 300: 0.04, 950: 0.1, 2500: 0.2},
+        SupportedFeatures(custom_token=False, wallet=True, payment=True),
+        0.05,
+    )
+
+    SUI = Blockchain(
+        "sui",
+        "SUI",
+        "SUI Network",
+        "SUI",
+        "https://suiscan.xyz/mainnet/coin",
+        False,
+        {
+            3: {3: 170, 6: 295, 12: 505, 24: 845},
+            10: {3: 125, 6: 230, 12: 395, 24: 675},
+        },
+        ["SUI", "USDC"],
+        {150: 0.02, 300: 0.04, 950: 0.1, 2500: 0.2},
+        SupportedFeatures(custom_token=False, wallet=True, payment=True),
+        10,
+    )
+
+    XPL = Blockchain(
+        "plasma",
+        "XPL",
+        "Plasma",
+        "XPL",
+        "https://plasmascan.to/token",
+        True,
+        {
+            3: {3: 518, 6: 951, 12: 1677, 24: 2715},
+            10: {3: 415, 6: 726, 12: 1487, 24: 1989},
+        },
+        ["WXPL", "USDT0", "USDC", "XPL"],
+        {150: 0.02, 300: 0.04, 950: 0.1, 2500: 0.2},
+        SupportedFeatures(custom_token=False, wallet=True, payment=True),
+        10,
+    )
+
+    @staticmethod
+    @lru_cache()
+    def dict() -> Dict[str, Blockchain]:
+        return {
+            BlockchainId.SOL: Blockchains.SOL,
+            BlockchainId.ETH: Blockchains.ETH,
+            BlockchainId.BSC: Blockchains.BSC,
+            BlockchainId.TRX: Blockchains.TRX,
+            BlockchainId.BASE: Blockchains.BASE,
+            BlockchainId.SUI: Blockchains.SUI,
+            BlockchainId.MANTA: Blockchains.MANTA,
+            BlockchainId.MATIC: Blockchains.MATIC,
+            BlockchainId.XPL: Blockchains.XPL,
+        }
+
+    @staticmethod
+    def all() -> List[Blockchain]:
+        return Blockchains.dict().values()
+
+    @lru_cache()
+    def get_by_id(id: str) -> Blockchain:
+        """Retrieve a blockchain by its ID."""
+        return Blockchains.dict().get(id)
+
+    @lru_cache()
+    def get_all_ids() -> List[str]:
+        """Return a list of all blockchain IDs."""
+        return Blockchains.dict().keys()
+
+    @lru_cache()
+    def all_chain_types() -> Set[str]:
+        """Return a list of all blockchain IDs."""
+        types = {c.chain_type for c in Blockchains.all()}
+        return types
+
+    @lru_cache()
+    def evms() -> List[Blockchain]:
+        """Retrieve all EVM-compatible blockchains."""
+        return [chain for chain in Blockchains.all() if chain.evm]
+
+    @staticmethod
+    @lru_cache()
+    def get_by_chain_type(chain_type: str) -> List[Blockchain]:
+        return [chain for chain in Blockchains.all() if chain.chain_type == chain_type]
+
+    @staticmethod
+    @lru_cache()
+    def get_chain_symbols() -> List[str]:
+        return [c.symbol for c in Blockchains.all()]
+
+    @staticmethod
+    @lru_cache()
+    def get_active_wallet_chains() -> List[str]:
+        chain_types = Blockchains.all_chain_types()
+        active_chain_types = []
+        for chain_type in chain_types:
+            chain = Blockchains.get_by_chain_type(chain_type)[0]
+            if chain and chain.supported_features.wallet:
+                active_chain_types.append(chain_type)
+        return active_chain_types