swap integerated

chatxbt-assistant.py

@@ -23,6 +23,50 @@ storage = PgAssistantStorage(
     db_engine=sqlalchemy_engine
 )
 
+@cl.on_chat_start
+async def start():
+    is_dev_mode = True if os.getenv("DEV_MODE") else False
+
+    # Initialize the assistant
+    cxbt_assistant = Assistant(
+        llm=OpenAIChat(model="gpt-4o"),
+        tools=[
+            UserProfileToolkit(),
+            DuckDuckGo(),
+            CryptoDataTools(),
+            CryptoSwapTools(),
+            CryptoEVMWalletTools(),
+            UserConfirmationPinToolkit(),
+            YFinanceTools(stock_price=True)
+        ],
+        show_tool_calls=is_dev_mode,
+        markdown=True,
+        knowledge_base=knowledge_base,
+        storage=storage,
+        search_knowledge=True,
+        read_chat_history=True,
+        add_references_to_prompt=True,
+        add_chat_history_to_prompt=True
+    )
+    cxbt_assistant.knowledge_base.load(recreate=False)
+
+    # Set the assistant in the user session
+    cl.user_session.set("agent", cxbt_assistant)
+
+@cl.on_message
+async def main(message: cl.Message):
+
+    # Retrieve the assistant from the user session
+    agent = cl.user_session.get("agent")
+
+    # Process the user message using the assistant
+    response = ""
+    for delta in agent.run(message.content, stream=True):
+        response += delta
+    
+    # Send the response back to the user
+    await cl.Message(content=response).send()
+
 @cl.oauth_callback
 def oauth_callback(
   provider_id: str,
@@ -81,50 +125,6 @@ async def set_starters():
             )
         ]
 
-@cl.on_chat_start
-async def start():
-    is_dev_mode = True if os.getenv("DEV_MODE") else False
-
-    # Initialize the assistant
-    cxbt_assistant = Assistant(
-        llm=OpenAIChat(model="gpt-4o"),
-        tools=[
-            UserProfileToolkit(),
-            DuckDuckGo(),
-            CryptoDataTools(),
-            CryptoSwapTools(),
-            CryptoEVMWalletTools(),
-            UserConfirmationPinToolkit(),
-            YFinanceTools(stock_price=True)
-        ],
-        show_tool_calls=is_dev_mode,
-        markdown=True,
-        knowledge_base=knowledge_base,
-        storage=storage,
-        search_knowledge=True,
-        read_chat_history=True,
-        add_references_to_prompt=True,
-        add_chat_history_to_prompt=True
-    )
-    cxbt_assistant.knowledge_base.load(recreate=False)
-
-    # Set the assistant in the user session
-    cl.user_session.set("agent", cxbt_assistant)
-
-@cl.on_message
-async def main(message: cl.Message):
-
-    # Retrieve the assistant from the user session
-    agent = cl.user_session.get("agent")
-
-    # Process the user message using the assistant
-    response = ""
-    for delta in agent.run(message.content, stream=True):
-        response += delta
-    
-    # Send the response back to the user
-    await cl.Message(content=response).send()
-
 # Run the Chainlit application
 if __name__ == "__main__":
     cl.run()

src/libs/rpc_client.py

@@ -49,4 +49,4 @@ async def rpc_call(
             return response.json()
     except httpx.RequestError as e:
         print(f"Error making RPC call: {e}")
-        return None
+        raise ValueError(f"Error making RPC call: {e}")

src/tools/crypto_swap_toolkit.py

@@ -99,58 +99,49 @@ class CryptoSwapTools(Toolkit):
         response = asyncio.run(rpc_call(method_name="getSwapSources"))
         return f"{response}"
 
-    def execute_swap(self, buy_token: str, sell_token: str, sell_amount: str, eth_address: str) -> str:
+    def execute_swap(
+            self,
+            buy_token: str,
+            sell_token: str,
+            sell_amount: str,
+            user_email: str,
+            chain: str = "base",
+    ) -> str:
         """
         Executes a swap using the 0x Swap API.
 
         Args:
-        buy_token (str): The token to buy (e.g., 'DAI').
-        sell_token (str): The token to sell (e.g., 'ETH').
-        sell_amount (str): The amount of the sell token to swap, in the smallest unit (e.g., wei for ETH).
-        eth_address (str): The Ethereum address of the user executing the swap.
+        -buy_token (str): The token to buy (e.g., 'DAI').
+        -sell_token (str): The token to sell (e.g., 'ETH').
+        -sell_amount (str): The amount of the sell token to swap, in the smallest unit (e.g., wei for ETH).
+        - user_email (str): The email of the user for whom the wallet is being fetched.
+        - chain (str): The EVM chain for which the wallet is being fetched and used to execute this transaction. use chain base as default
 
         Returns:
         dict: The transaction receipt of the swap transaction.
 
         Example:
-        >>> execute_swap('DAI', 'ETH', '1000000000000000000', '0xYourEthereumAddress')
+        >>> execute_swap('DAI', 'ETH', '1000000000000000000', 'userEmail', 'base')
         """
-        # 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("executing swap")
         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': {
+                  "userEmail": user_email,
+                  "chain": chain,
+                  "testnet": True,
+                  "gasless": True,
+                  "connected": True
+                }
             }
-            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:
+            response = asyncio.run(rpc_call(method_name="swapTokens", params=params))
+            logger.info(f"Swap transaction receipt: {response}")
+            return f"{response}"
+        except requests.exceptions.RequestException as e:
             logger.warning(f"Failed to execute swap: {e}")
             # return {"error": str(e)}
             return f"Error: {e}"

src/tools/user_profile_toolkit.py

@@ -21,6 +21,9 @@ class UserProfileToolkit(Toolkit):
         self.register(self.update_user_picture)
         self.register(self.get_user_id)
 
+        # fetching user email
+        self.email = self.get_user_email()
+
     @cl.on_chat_start
     def get_user_info(self, info_type: str) -> str:
         """