added cross chain swap toolkit

Procfile

@@ -1 +1 @@
-web: docker-compose up --build
+web: python -m chainlit run chatxbt-assistant.py -h --port 8080

chatxbt-assistant.py

@@ -6,10 +6,12 @@ load_dotenv()
 import chainlit as cl
 from phi.assistant import Assistant
 from phi.llm.openai import OpenAIChat
+from phi.llm.groq import Groq
 from phi.tools.duckduckgo import DuckDuckGo
 from phi.tools.yfinance import YFinanceTools
 from src.databases.postgres import sqlalchemy_engine
 from src.tools.crypto_swap_toolkit import CryptoSwapTools
+from src.tools.crypto_bridge_toolkit import CrossChainSwapTools
 from src.tools.crypto_data_toolkit import CryptoDataTools
 from src.tools.crypto_evm_wallet_toolkit import CryptoEVMWalletTools
 from src.tools.user_profile_toolkit import UserProfileToolkit
@@ -85,18 +87,18 @@ async def set_starters():
 async def start():
     is_dev_mode = True if os.getenv("DEV_MODE") else False
 
-    print(instruction)
-
     # Initialize the assistant
     cxbt_assistant = Assistant(
         description=description,
         instruction=instruction,
-        llm=OpenAIChat(model="gpt-4o"),
+        # llm=OpenAIChat(model="gpt-4o"),
+        llm=Groq(model="llama3-70b-8192"),
         tools=[
             UserProfileToolkit(),
             DuckDuckGo(),
             CryptoDataTools(),
             CryptoSwapTools(),
+            CrossChainSwapTools(),
             CryptoEVMWalletTools(),
             YFinanceTools(stock_price=True)
         ],

src/libs/rpc_client.py

@@ -27,11 +27,15 @@ async def rpc_call(
         httpx.RequestError: If an error occurs while making the RPC call.
 
     """
-    headers ={
+    headers = {
         'Content-Type': 'application/json',
-        "authorization": f'Basic {os.getenv('CHATXBT_RPC_SERVER_BASIC_AUTH_CREDENTIALS')}'
     }
 
+    auth = httpx.BasicAuth(
+        username=os.getenv('CHATXBT_RPC_SERVER_BASIC_AUTH_USERNAME'),
+        password=os.getenv('CHATXBT_RPC_SERVER_BASIC_AUTH_PASSWORD')
+    )
+
     payload = {
         'method': method_name,
         'params': params,
@@ -41,7 +45,7 @@ async def rpc_call(
 
     try:
         async with httpx.AsyncClient() as client:
-            response = await client.post(url, json=payload, headers=headers)
+            response = await client.post(url, json=payload, headers=headers, auth=auth)
             response.raise_for_status()
             return response.json()
     except httpx.RequestError as e:

src/tools/crypto_bridge_toolkit.py

@@ -0,0 +1,167 @@
+from typing import TypedDict, Any
+import asyncio
+from phi.tools import Toolkit
+from phi.utils.log import logger
+from src.libs.rpc_client import rpc_call
+
+# Define TypedDict for wallet
+class WalletParams(TypedDict):
+    userEmail: str
+    chain: str
+    testnet: bool
+    gasless: bool
+
+# Define TypedDict for tokenIn and tokenOut (since they have identical structures)
+class TokenParams(TypedDict):
+    chainId: int
+    address: str
+    decimals: int
+    symbol: str
+    name: str
+
+class CrossChainSwapTools(Toolkit):
+    def __init__(self):
+        super().__init__(name="cross_chain_swap_tools")
+
+        # Registering methods to make them accessible via the toolkit
+        self.register(self.cross_chain_swap)
+        self.register(self.get_bridge_chains)
+        self.register(self.get_cross_chain_swap_token_list)
+
+    def cross_chain_swap(
+        self,
+        chainId: int,
+        amountLD: str,
+        recipient: str,
+        wallet: Any,
+        tokenIn: Any,
+        tokenOut: Any
+    ) -> str:
+        """
+        Performs a cross-chain token swap.
+
+        Parameters:
+        - chainId (int): The ID of the chain.
+        - amountLD (str): The amount to be swapped, in lowest denomination (e.g., wei for ETH).
+        - recipient (str): The recipient address.
+        - wallet (WalletParams): The wallet parameters.
+        - tokenIn (TokenParams): The input token parameters.
+        - tokenOut (TokenParams): The output token parameters.
+
+        Returns:
+        - str: A string representation of the response from the RPC call.
+
+        Raises:
+        None
+
+        Note:
+        This method uses `asyncio.run()` to run the asynchronous RPC call.
+        """
+        logger.info(f"Performing cross-chain swap on chain {chainId} for recipient {recipient}")
+
+        params = {
+            'chainId': chainId,
+            'amountLD': amountLD,
+            'recipient': recipient,
+            'wallet': wallet,
+            'tokenIn': tokenIn,
+            'tokenOut': tokenOut,
+        }
+        response = asyncio.run(rpc_call(method_name="crossChainSwap", params=params))
+        return self._format_response(response)
+
+    def get_bridge_chains(self, chainId: int) -> str:
+        """
+        Fetches the list of supported bridge chains.
+
+        Parameters:
+        - chainId (int): The ID of the chain. Supported values:
+            - 1: Ethereum
+            - 10: Optimism
+            - 56: BNB Chain
+            - 100: Gnosis Chain
+            - 137: Polygon
+            - 324: zkSync Era
+            - 1088: Metis
+            - 8453: Base
+            - 42161: Arbitrum
+            - 43114: Avalanche
+        """
+        logger.info(f"Fetching supported bridge chains for chain ID {chainId}")
+
+        params = {'chainId': chainId}
+        response = asyncio.run(rpc_call(method_name="getBridgeChains", params=params))
+        return self._format_response(response)
+
+    def get_cross_chain_swap_token_list(self, chainId: int) -> str:
+        """
+        Fetches the list of supported cross-chain swap tokens on the specified chainId.
+
+        Parameters:
+        - chainId (int): The ID of the chain.
+
+        Returns:
+        - str: A string representation of the response from the RPC call containing the list of cryptocurrency tokens,
+        each with details about their source token and the corresponding destination
+        tokens on different blockchain networks.
+
+        Raises:
+        None
+
+        Note:
+        This method uses `asyncio.run()` to run the asynchronous RPC call.
+        present data in proper nice readable format
+        """
+        logger.info(f"Fetching cross-chain swap token list for chain ID {chainId}")
+
+        params = {'chainId': chainId}
+        response = asyncio.run(rpc_call(method_name="getCrossChainSwapTokenList", params=params))
+        return self._format_response(response)
+
+    def _format_response(self, response: dict) -> str:
+        """
+        Formats the response from the RPC call into a readable string.
+
+        Parameters:
+        - response (dict): The response from the RPC call.
+
+        Returns:
+        - str: A formatted string representation of the response.
+        """
+        if 'error' in response:
+            logger.error(f"RPC call failed with error: {response['error']}")
+            return f"Error: {response['error']}"
+        return f"Response: {response}"
+
+# Example usage:
+# toolkit = CrossChainSwapTools()
+# print(toolkit.get_bridge_chains(1))
+# print(toolkit.get_cross_chain_swap_token_list(1))
+# swap_params = {
+#     "chainId": 1,
+#     "amountLD": "100",
+#     "recipient": "0xRecipientAddress",
+#     "wallet": {
+#         "userEmail": "user@example.com",
+#         "chain": "ethereum",
+#         "testnet": True,
+#         "gasless": True
+#     },
+#     "tokenIn": {
+#         "chainId": 1,
+#         "address": "0xInputTokenAddress",
+#         "decimals": 18,
+#         "symbol": "TOKEN_IN",
+#         "name": "Input Token",
+#         "logoUri": "https://example.com/logo_in.png"
+#     },
+#     "tokenOut": {
+#         "chainId": 137,
+#         "address": "0xOutputTokenAddress",
+#         "decimals": 18,
+#         "symbol": "TOKEN_OUT",
+#         "name": "Output Token",
+#         "logoUri": "https://example.com/logo_out.png"
+#     }
+# }
+# print(toolkit.cross_chain_swap(**swap_params))

src/tools/crypto_swap_toolkit.py

@@ -115,42 +115,19 @@ class CryptoSwapTools(Toolkit):
         Example:
         >>> execute_swap('DAI', 'ETH', '1000000000000000000', '0xYourEthereumAddress')
         """
-        # Get the swap quote
-        quote = json.loads(self.get_swap_quote(buy_token, sell_token, sell_amount))
-        logger.info(f"Swap quote: {quote}")
-
-        if 'error' in quote:
-            # return {"error": "Failed to get swap quote"}
-            return f"Error: Failed to get swap quote"
-
-        # Approve the token if needed (skip if selling ETH)
-        if sell_token != 'ETH':
-            approval_receipt = self.token_approval_helper.approve_token(sell_token, quote['allowanceTarget'],
-                                                                        sell_amount, eth_address)
-            logger.info(f"Approval receipt: {approval_receipt}")
-
-            if 'status' not in approval_receipt or approval_receipt['status'] != 1:
-                # return {"error": "Token approval failed"}
-                return f"Error: Token approval failed"
-
-        # Execute the swap
+        logger.info(f"wap token: buying {buy_token} with {sell_token} amount {sell_amount}")
         try:
-            swap_tx = {
-                'from': eth_address,
-                'to': quote['to'],
-                'data': quote['data'],
-                'value': int(quote['value']),
-                'gas': 200000,
-                'gasPrice': self.web3.to_wei('20', 'gwei'),
-                'nonce': self.web3.eth.get_transaction_count(eth_address)
+            params = {
+                'buyToken': buy_token,
+                'sellToken': sell_token,
+                'sellAmount': sell_amount,
+                'wallet': {
+
+                }
             }
-            signed_swap_tx = self.web3.eth.account.signTransaction(swap_tx, private_key=get_private_key())
-            tx_hash = self.web3.eth.send_raw_transaction(signed_swap_tx.rawTransaction)
-            receipt = self.web3.eth.wait_for_transaction_receipt(tx_hash)
-            logger.info(f"Swap transaction receipt: {receipt}")
-            # return receipt
-            return f"{(receipt)}"
-        except Exception as e:
-            logger.warning(f"Failed to execute swap: {e}")
+            response = asyncio.run(rpc_call(method_name="swapTokens", params=params))
+            return f"{response}"
+        except requests.exceptions.RequestException as e:
+            logger.warning(f"Failed to swap tokens: {e}")
             # return {"error": str(e)}
             return f"Error: {e}"

src/tools/user_profile_toolkit.py

@@ -16,6 +16,7 @@ class UserProfileToolkit(Toolkit):
         self.register(self.update_user_name)
         self.register(self.update_user_email)
         self.register(self.update_user_picture)
+        self.allUserInfo = self.get_all_user_info()
 
     @cl.on_chat_start
     def get_user_info(self, info_type: str = "name") -> str: