fixed swap and bridging

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -1,25 +1,34 @@
 # Use an official Python runtime as a parent image
 FROM python:3.11-slim
 
+# Create a user and set permissions
+RUN useradd -m -u 1000 user
+
 # Set the working directory in the container
 WORKDIR /app
 
-# Install PostgreSQL client libraries and development headers
+# Install system dependencies
+USER root
 RUN apt-get update && apt-get install -y \
+    python3-dev \
     libpq-dev \
     gcc \
     && rm -rf /var/lib/apt/lists/*
 
+# Ensure .files directory exists and is writable
+RUN mkdir -p /app/.files && chown -R user:user /app/.files
+
+# Switch back to the non-root user
+USER user
+
 # Copy the rest of the application code into the container
-COPY . .
+COPY --chown=user . .
 
 # Install any needed packages specified in requirements.txt
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Make port 8501 available to the world outside this container
-#EXPOSE 8000
-EXPOSE 8080
+# Expose port 8080 to the world outside this container
+EXPOSE 7860
 
 # Run chainlit when the container launches
-CMD ["python", "-m", "chainlit", "run", "chatxbt-assistant.py", "-h", "--port", "8080"]
-
+CMD ["python", "-m", "chainlit", "run", "chatxbt-assistant.py", "-h", "--port", "7860"]

README.md

@@ -1,11 +1,21 @@
-# ChatXBT Web3 AI Assitant Service
+---
+title: ChatXBT
+emoji: 💬
+colorFrom: purple
+colorTo: pink
+sdk: docker
+sdk_version: "latest"
+app_file: chatxbt-assistant.py
+pinned: false
+---
+
+# ChatXBT Web3 AI Assistant Service
 
 AI-powered unification and execution protocol for web3 applications
 
-
 ## Requirements
 
-The list below contains all the requirements needed to have a complete developer environment to sart working on this project.
+The list below contains all the requirements needed to have a complete developer environment to start working on this project.
 Follow the links to install or update these tools on your machine.
 
 1. [Python 3.12+](https://www.python.org/downloads/release/python-3120/)
@@ -13,17 +23,15 @@ Follow the links to install or update these tools on your machine.
 3. [Pip Installer](https://pip.pypa.io/en/stable/installation/)
 4. [Python Venv](https://docs.python.org/3/library/venv.html)
 
-
 ## Installation
 
 1. Clone the repository: `git clone https://github.com/ChatXBT/chatxbt-web3-ai-assistant.git`
-2. Get a copy of the `\`.env`\` file from the project manager`
+2. Get a copy of the `.env` file from the project manager
 3. Create a virtual environment: `python -m venv env`
 4. Activate the virtual environment: `source env/bin/activate`
-4. Install the dependencies: `pip install -r requirements.txt`
-5. Run the application: `chainlit run chatxbt-assistant.py -w`
-6. Open the application in your browser: `http://localhost:8000`
-
+5. Install the dependencies: `pip install -r requirements.txt`
+6. Run the application: `chainlit run chatxbt-assistant.py -w`
+7. Open the application in your browser: `http://localhost:8000`
 
 ## Project Overview
 
@@ -36,17 +44,15 @@ The project is structured as follows:
 5. src/search_services: `a list of search services that can be used to retrieve data for the AI assistant.`
 6. src/tools: `a list of tools that can be used to extend the functionality of the AI assistant.`
 
-
 ## Guides
 
 1. Follow the development, structure and documentation patterns of the `src/tools/coin_data_toolkit.py` to build custom toolkits
 2. Follow the development, structure and documentation patterns of the `src/tools/coin_data_toolkit.py` to build classes 
-3. Pay attention to the `constants` variables and `caching` decorators to optimize perfomance of class functions/methods across the project
+3. Pay attention to the `constants` variables and `caching` decorators to optimize performance of class functions/methods across the project
 4. Create new classes in the appropriate folders to maintain an organized codebase and project
 5. After installing any new package run `` to update the dependency requirements list
 6. Expose RPC functions for SDKs that do not support python runtime. use [DeepKit](https://deepkit.io/documentation/rpc) and [BunJS](https://bun.sh/) if possible.
 
-
 ## Git Workflow
 
 For this project, we will be using a very simple version of the Gitflow workflow. This workflow is designed to manage the development, release, and maintenance of software projects. It provides a clear and structured approach to managing branches, releases, and feature development.
@@ -68,21 +74,19 @@ For this project, we will be using a very simple version of the Gitflow workflow
 3. Push your changes to the remote repository: `git push origin bugfix/my-bugfix`
 4. Open a pull request on GitHub and request a review from a team member.
 5. Deploy the bugfix branch to a staging environment for testing.
-6. Once testing is finished, merge the pull  request into the main branch.
+6. Once testing is finished, merge the pull request into the main branch.
 7. Once the pull request is approved, merge it into the main branch.
 8. Delete the bugfix branch: `git branch -d bugfix/my-bugfix`
 9. Update your local main branch: `git checkout main && git pull origin main`
 
-
-## Deplopyment to producton
+## Deployment to production
 
 To be finalised and added
 
-
 ## TODO
 
 1. Add deployment instructions
 2. Setup CI/CD pipelines for automatic deployment
 3. Setup and integrate `LiteLLM` instance for LLM service high availability
-4. Add RPC class for remmote method calls to other chatxbt services written in other launguages such as `JS`, `TS` & `GO`
-5. Write enough unit test to ensure class and function input and output correctness
+4. Add RPC class for remote method calls to other ChatXBT services written in other languages such as `JS`, `TS` & `GO`
+5. Write enough unit tests to ensure class and function input and output correctness

chatxbt-assistant.py

@@ -1,23 +1,28 @@
-import os
+import os, json
 from typing import Optional, Dict
 from dotenv import load_dotenv
+
 load_dotenv()
 
 import chainlit as cl
 from phi.assistant import Assistant
 from phi.llm.openai import OpenAIChat
+from phi.llm.ollama import Ollama
 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.knowledge_bases.combined import knowledge_base
 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 portkey_ai import PORTKEY_GATEWAY_URL, createHeaders
+from src.config.portkey_config import generate_portkey_config
 from src.tools.user_profile_toolkit import UserProfileToolkit
 from phi.storage.assistant.postgres import PgAssistantStorage
-from src.knowledge_bases.combined import knowledge_base
-from src.config.assistant import description, instruction
+from src.tools.crypto_evm_wallet_toolkit import CryptoEVMWalletTools
+from src.tools.user_confirmation_pin_toolkit import UserConfirmationPinToolkit
+
 
 storage = PgAssistantStorage(
     # stores runs in the ai.assistant_runs table
@@ -87,19 +92,22 @@ async def set_starters():
 async def start():
     is_dev_mode = True if os.getenv("DEV_MODE") else False
 
+    portkey_local_gateway = True if os.getenv("PORTKEY_LOCAL_GATEWAY_URL") else False
+    portkey_config = generate_portkey_config(local=portkey_local_gateway)
+
     # Initialize the assistant
     cxbt_assistant = Assistant(
-        description=description,
-        instruction=instruction,
-        # llm=OpenAIChat(model="gpt-4o"),
-        llm=Groq(model="llama3-70b-8192"),
+        # llm=OpenAIChat(),
+        # llm=Groq(model="llama3-70b-8192"),
+        llm=Ollama(model="llama3"),
         tools=[
-            UserProfileToolkit(),
             DuckDuckGo(),
             CryptoDataTools(),
             CryptoSwapTools(),
             CrossChainSwapTools(),
+            UserProfileToolkit(),
             CryptoEVMWalletTools(),
+            UserConfirmationPinToolkit(),
             YFinanceTools(stock_price=True)
         ],
         show_tool_calls=is_dev_mode,
@@ -109,7 +117,9 @@ async def start():
         search_knowledge=True,
         read_chat_history=True,
         add_references_to_prompt=True,
-        add_chat_history_to_prompt=True
+        add_chat_history_to_prompt=True,
+        prevent_hallucinations=True,
+        prevent_prompt_injection=True
     )
     cxbt_assistant.knowledge_base.load(recreate=False)
 
@@ -119,16 +129,20 @@ async def start():
 @cl.on_message
 async def main(message: cl.Message):
 
+    msg = cl.Message(content="")
+    await msg.send()
+
     # 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()
+        for part in delta:
+            if token := part or "":
+                # Send the response back to the user
+                await msg.stream_token(token)
+
+    await msg.update()
 
 # Run the Chainlit application
 if __name__ == "__main__":

docker-compose.yml

@@ -3,7 +3,7 @@ services:
     image: chatxbt-web3-ai-assistant
     build: .
     ports:
-      - "8080:8080"
+      - "7860:7860"
     env_file:
       - .env
     depends_on:

requirements.txt

@@ -8,12 +8,14 @@ anthropic==0.28.0
 anyio==3.7.1
 appdirs==1.4.4
 appnope==0.1.4
+APScheduler==3.10.4
 asgiref==3.8.1
 asttokens==2.4.1
 async-timeout==4.0.3
 asyncer==0.0.2
 attrs==23.2.0
 backcall==0.2.0
+backoff==2.2.1
 baize==0.20.8
 beautifulsoup4==4.12.3
 bidict==0.23.1
@@ -21,22 +23,26 @@ bitarray==2.9.2
 bleach==6.1.0
 boto3==1.34.106
 botocore==1.34.106
+cached-property==1.5.2
 certifi==2024.6.2
+cffi==1.16.0
 chainlit==1.1.300
 charset-normalizer==3.3.2
-psycopg2-binary==2.9.9
 chevron==0.14.0
 ckzg==1.0.2
 click==8.1.7
 coingecko==0.13
+cryptography==42.0.8
 cytoolz==0.12.3
 dataclasses-json==0.5.14
 decorator==5.1.1
 defusedxml==0.7.1
 Deprecated==1.2.14
 distro==1.9.0
+dnspython==2.6.1
 docopt==0.6.2
 duckduckgo_search==6.1.6
+email_validator==2.2.0
 eth-account==0.11.2
 eth-hash==0.7.0
 eth-keyfile==0.8.1
@@ -47,7 +53,9 @@ eth-utils==4.1.1
 eth_abi==5.1.0
 exceptiongroup==1.2.1
 executing==2.0.1
-fastapi==0.110.3
+fastapi==0.111.1
+fastapi-cli==0.0.4
+fastapi-sso==0.10.0
 fastjsonschema==2.19.1
 filelock==3.15.1
 filetype==1.2.0
@@ -62,10 +70,12 @@ google_search_results==2.4.2
 googleapis-common-protos==1.63.1
 greenlet==3.0.3
 grpcio==1.64.1
+gunicorn==22.0.0
 h11==0.14.0
 hexbytes==0.3.1
 html5lib==1.1
 httpcore==1.0.5
+httptools==0.6.1
 httpx==0.27.0
 huggingface-hub==0.23.3
 idna==3.7
@@ -92,6 +102,7 @@ langchainhub==0.1.20
 langgraph==0.0.68
 langsmith==0.1.77
 Lazify==0.4.0
+litellm==1.41.21
 literalai==0.0.604
 logfire==0.42.0
 lru-dict==1.2.0
@@ -104,6 +115,7 @@ mdurl==0.1.2
 mistune==3.0.2
 multidict==6.0.5
 multitasking==0.0.11
+mypy==1.10.1
 mypy-extensions==1.0.0
 nbclient==0.10.0
 nbconvert==7.16.4
@@ -111,6 +123,7 @@ nbformat==5.10.4
 nest-asyncio==1.6.0
 numexpr==2.10.0
 numpy==1.26.4
+oauthlib==3.2.2
 openai==1.34.0
 opentelemetry-api==1.25.0
 opentelemetry-exporter-otlp==1.25.0
@@ -142,6 +155,7 @@ pickleshare==0.7.5
 pipdeptree==2.22.0
 pipreqs==0.5.0
 platformdirs==4.2.2
+portkey-ai==1.7.0
 prompt_toolkit==3.0.47
 protobuf==4.25.3
 psutil==5.9.8
@@ -149,6 +163,7 @@ psycopg==3.1.19
 psycopg2==2.9.9
 ptyprocess==0.7.0
 pure-eval==0.2.2
+pycparser==2.22
 pycryptodome==3.20.0
 pydantic==2.7.4
 pydantic-settings==2.3.3
@@ -175,6 +190,7 @@ rich==13.7.1
 rlp==4.0.1
 rpc.py==0.6.0
 rpds-py==0.18.1
+rq==1.16.2
 s3fs==2024.6.0
 s3transfer==0.10.1
 shellingham==1.5.4
@@ -202,11 +218,13 @@ types-requests==2.32.0.20240602
 typing-inspect==0.9.0
 typing_extensions==4.12.2
 tzdata==2024.1
+tzlocal==5.2
 ulid==1.1
 upstash-redis==1.1.0
 uptrace==1.24.0
 urllib3==2.2.1
-uvicorn==0.25.0
+uvicorn==0.22.0
+uvloop==0.19.0
 watchfiles==0.20.0
 wcwidth==0.2.13
 web3==6.19.0

src/config/nemoguardrails/config.yml

@@ -0,0 +1,27 @@
+# config.yml
+models:
+  - type: main
+    engine: openai
+    model: gpt-3.5-turbo-instruct
+
+rails:
+  # Input rails are invoked when new input from the user is received.
+  input:
+    flows:
+      - check jailbreak
+      - mask sensitive data on input
+
+  # Output rails are triggered after a bot message has been generated.
+  output:
+    flows:
+      - self check facts
+      - self check hallucination
+      - activefence moderation
+
+  config:
+    # Configure the types of entities that should be masked on user input.
+    sensitive_data_detection:
+      input:
+        entities:
+          - PERSON
+          - EMAIL_ADDRESS

src/config/portkey_config.py

@@ -0,0 +1,108 @@
+import json
+import os
+
+def generate_portkey_config(local: bool = True):
+    if local:
+        config = {
+            "strategy": {
+                "mode": "fallback"
+            },
+            "cache": {
+                "mode": "semantic",
+                "max_age": 10000
+            },
+            "retry": {
+                "attempts": 3,
+                "on_status_codes": [429]
+            },
+            "targets": [
+                # {
+                #     "provider": "mistral-ai",
+                #     "api_key": os.getenv("MISTRAL_API_KEY"),
+                #     "override_params": {
+                #         "model": "codestral-latest",
+                #         "max_tokens": 1024,
+                #         "temperature": 0
+                #     }
+                # },
+                {
+                    "provider": "anthropic",
+                    "api_key": os.getenv("ANTHROPIC_API_KEY"),
+                    "override_params": {
+                        "model": "claude-3-5-sonnet-20240620",
+                        "max_tokens": 1024,
+                        "temperature": 0
+                    }
+                },
+                {
+                    "provider": "openai",
+                    "api_key": os.getenv("OPENAI_API_KEY"),
+                    "override_params": {
+                        "model": "gpt-4o",
+                        "max_tokens": 1024,
+                        "temperature": 0
+                    }
+                },
+                {
+                    "provider": "anthropic",
+                    "api_key": os.getenv("ANTHROPIC_API_KEY"),
+                    "override_params": {
+                        "model": "claude-3-opus-20240229",
+                        "max_tokens": 1024,
+                        "temperature": 0
+                    }
+                }
+            ]
+        }
+    else:
+        config = {
+            "strategy": {
+                "mode": "fallback"
+            },
+            "cache": {
+                "mode": "semantic",
+                "max_age": 10000
+            },
+            "retry": {
+                "attempts": 3,
+                "on_status_codes": [429]
+            },
+            "targets": [
+                
+                {
+                    "virtual_key": os.getenv("PORTKEY_OPENAI_VIRTUAL_KEY"),
+                    "override_params": {
+                        "model": "gpt-4o",
+                        "max_tokens": 1024,
+                        "temperature": 0
+                    }
+                },
+                {
+                    "provider": "anthropic",
+                    "api_key": os.getenv("POETRY_ANTHROPIC_API_KEY"),
+                    "override_params": {
+                        "model": "claude-3-5-sonnet-20240620",
+                        "max_tokens": 1024,
+                        "temperature": 0
+                    }
+                },
+                {
+                    "virtual_key": os.getenv("PORTKEY_ANTHROPIC_API_KEY"),
+                    "override_params": {
+                        "model": "claude-3-opus-20240229",
+                        "max_tokens": 1024,
+                        "temperature": 0
+                    }
+                },
+                {
+                    "virtual_key": os.getenv("PORTKEY_MISTRAL_API_KEY"),
+                    "override_params": {
+                        "model": "codestral-latest",
+                        "max_tokens": 1024,
+                        "temperature": 0
+                    }
+                }
+            ]
+        }
+    
+    return json.dumps(config)

src/libs/rpc_client.py

@@ -1,7 +1,6 @@
 import httpx, uuid, os
 from typing import Optional, Union
 from dotenv import load_dotenv
-from src.libs.logger import logger
 
 load_dotenv()
 
@@ -10,7 +9,8 @@ rpc_server_url = os.getenv('CHATXBT_RPC_SERVER_URL')
 async def rpc_call(
     method_name: str,  # The name of the RPC method to be called
     params: Optional[Union[dict, list]] = None,  # Optional parameters for the RPC method
-    url: str = rpc_server_url  # The URL of the RPC server
+    url: str = rpc_server_url,  # The URL of the RPC server
+    timeout: int = 60  # Timeout in seconds
 ) -> dict:  # Returns the JSON response from the RPC server
     """
     This function makes an RPC call to the specified URL with the given method name and parameters.
@@ -44,10 +44,10 @@ async def rpc_call(
     }
 
     try:
-        async with httpx.AsyncClient() as client:
+        async with httpx.AsyncClient(timeout=timeout) as client:
             response = await client.post(url, json=payload, headers=headers, auth=auth)
             response.raise_for_status()
             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_bridge_toolkit.py

@@ -33,20 +33,22 @@ class CrossChainSwapTools(Toolkit):
         chainId: int,
         amountLD: str,
         recipient: str,
-        wallet: Any,
-        tokenIn: Any,
-        tokenOut: Any
+        user_email: str,
+        tokenIn: str,
+        tokenOut: str,
+        chain: str = "base",
     ) -> str:
         """
-        Performs a cross-chain token swap.
+        Performs a cross-chain token swap. this is a sensitive function, show a preview and allow user to give final permission to execute function
 
         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.
+        - user_email (str): The email of the user for whom the wallet is being fetched and used to sign the transaction.
+        - tokenIn (TokenParams): The input token parameters as structured from: get_cross_chain_swap_token_list. stringify object
+        - tokenOut (TokenParams): The output token parameters as structured from: get_cross_chain_swap_token_list. stringify object
+        - chain (str): The EVM chain for which the wallet is being fetched and used to execute this transaction. use chain base as default
 
         Returns:
         - str: A string representation of the response from the RPC call.
@@ -63,7 +65,13 @@ class CrossChainSwapTools(Toolkit):
             'chainId': chainId,
             'amountLD': amountLD,
             'recipient': recipient,
-            'wallet': wallet,
+            'wallet': {
+                "userEmail": user_email,
+                "chain": chain,
+                "testnet": True,
+                "gasless": True,
+                "connected": True
+            },
             'tokenIn': tokenIn,
             'tokenOut': tokenOut,
         }
@@ -95,7 +103,8 @@ class CrossChainSwapTools(Toolkit):
 
     def get_cross_chain_swap_token_list(self, chainId: int) -> str:
         """
-        Fetches the list of supported cross-chain swap tokens on the specified chainId.
+        Fetches the list of supported cross-chain swap tokens on the specified chainId. always call before executing
+        cross_chain_swap to get accurate tokenIn and tokenOut data
 
         Parameters:
         - chainId (int): The ID of the chain.

src/tools/crypto_evm_wallet_toolkit.py

@@ -9,9 +9,12 @@ class CryptoEVMWalletTools(Toolkit):
         super().__init__(name="crypto_evm_wallet_tools")
 
         # Registering methods to make them accessible via the toolkit
-        self.register(self.get_evm_wallet_address)
+        # self.register(self.get_evm_wallet_address)
         self.register(self.get_supported_evm_chains)
         self.register(self.get_evm_smart_wallet_address)
+        self.register(self.get_evm_smart_wallet_balances)
+
+        # Fetching the list of supported EVM chains
         self.chains = self.get_supported_evm_chains()
 
     def get_supported_evm_chains(self) -> list[str]:
@@ -30,14 +33,50 @@ class CryptoEVMWalletTools(Toolkit):
         response = asyncio.run(rpc_call(method_name="getEVMSupportedChains", params=params))
         return f"{response}"
 
-    def get_evm_wallet_address(self, user_email: str, chain: str, testnet: bool = True) -> str:
+    # def get_evm_wallet_address(self, user_email: str, chain: str, testnet: bool = True) -> str:
+    #     """
+    #     Fetches an EVM wallet address for the given user email and supported chain.
+    #     Creates and returns an EVM wallet address for the given user email and supported chain.
+
+    #     Parameters:
+    #     - user_email (str): The email of the user for whom the wallet is being created.
+    #     - chain (ethereum | binance | base | polygon): The EVM chain for which the wallet is being fetched.
+    #     - testnet (bool, optional): A flag indicating whether the wallet should be on the testnet. Defaults to `True`.
+
+    #     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"Creating crypto wallet account for {user_email}")
+
+    #     params = {
+    #         'chain': chain,
+    #         'testnet': testnet,
+    #         'userEmail': user_email,
+    #     }
+    #     response = asyncio.run(rpc_call(method_name="getEVMWallet", params=params))
+    #     return f"{response}"
+    
+    def get_evm_smart_wallet_address(
+        self,
+        user_email: str,
+        chain: str,
+        gasless: bool = True,
+        testnet: bool = True
+    ) -> str:
         """
-        Fetches an EVM wallet address for the given user email and supported chain.
-        Creates and returns an EVM wallet address for the given user email and supported chain.
+        Fetches a smart EVM wallet address for the given user email and supported chain.
+        Creates and returns a smart EVM wallet address for the given user email and supported chain.
 
         Parameters:
-        - user_email (str): The email of the user for whom the wallet is being created.
+        - user_email (str): The email of the user for whom the wallet is being fetched.
         - chain (ethereum | binance | base | polygon): The EVM chain for which the wallet is being fetched.
+        - gasless (bool, optional): A flag indicating whether the wallet should be gasless. Defaults to `True`.
         - testnet (bool, optional): A flag indicating whether the wallet should be on the testnet. Defaults to `True`.
 
         Returns:
@@ -47,37 +86,37 @@ class CryptoEVMWalletTools(Toolkit):
         None
 
         Note:
-        This method uses asyncio.run() to run the asynchronous RPC call.
+        This method uses `asyncio.run()` to run the asynchronous RPC call.
         """
-        logger.info(f"Creating crypto wallet account for {user_email}")
+        logger.info(f"Fetching crypto wallet account for {user_email}")
 
         params = {
             'chain': chain,
+            'gasless': gasless,
             'testnet': testnet,
             'userEmail': user_email,
         }
-        response = asyncio.run(rpc_call(method_name="getEVMWallet", params=params))
+        response = asyncio.run(rpc_call(method_name="getEVMSmartWallet", params=params))
         return f"{response}"
     
-    def get_evm_smart_wallet_address(
+    def get_evm_smart_wallet_balances(
         self,
+        address: str,
         user_email: str,
         chain: str,
-        gasless: bool = True,
         testnet: bool = True
     ) -> str:
         """
-        Fetches a smart EVM wallet address for the given user email and supported chain.
-        Creates and returns a smart EVM wallet address for the given user email and supported chain.
+        Fetches the balances of a smart EVM wallet address for the given user email and supported chain.
 
         Parameters:
+        - address (str): The address of the smart EVM wallet for which the balances are being fetched.
         - user_email (str): The email of the user for whom the wallet is being fetched.
-        - chain (ethereum | binance | base | polygon): The EVM chain for which the wallet is being fetched.
-        - gasless (bool, optional): A flag indicating whether the wallet should be gasless. Defaults to `True`.
+        - chain (str): The EVM chain for which the wallet is being fetched.
         - testnet (bool, optional): A flag indicating whether the wallet should be on the testnet. Defaults to `True`.
 
         Returns:
-        - str: A string representation of the response from the RPC call.
+        - str: A string representation of the response from the RPC call containing the balances of the smart EVM wallet address.
 
         Raises:
         None
@@ -89,9 +128,9 @@ class CryptoEVMWalletTools(Toolkit):
 
         params = {
             'chain': chain,
-            'gasless': gasless,
+            'address': address,
             'testnet': testnet,
             'userEmail': user_email,
         }
-        response = asyncio.run(rpc_call(method_name="getEVMSmartWallet", params=params))
+        response = asyncio.run(rpc_call(method_name="getEVMSmartWalletAddressBalances", params=params))
         return f"{response}"

src/tools/crypto_swap_toolkit.py

@@ -26,7 +26,7 @@ class CryptoSwapTools(Toolkit):
         self.register(self.get_swap_sources)
         self.register(self.execute_swap)
 
-    def get_swap_quote(self, buy_token: str, sell_token: str, sell_amount: str) -> str:
+    def get_swap_quote(self, buy_token: str, sell_token: str, sell_amount: str, chain: str = "base") -> str:
         """
         Fetches a swap quote from the 0x Swap API.
 
@@ -46,7 +46,14 @@ class CryptoSwapTools(Toolkit):
             params = {
                 'buyToken': buy_token,
                 'sellToken': sell_token,
-                'sellAmount': sell_amount
+                'sellAmount': sell_amount,
+                'wallet': {
+                    "userEmail": "none",
+                    "chain": chain,
+                    "testnet": True,
+                    "gasless": True,
+                    "connected": True
+                }
             }
             response = asyncio.run(rpc_call(method_name="getSwapQuote", params=params))
             return f"{response}"
@@ -55,7 +62,7 @@ class CryptoSwapTools(Toolkit):
             # return {"error": str(e)}
             return f"Error: {e}"
 
-    def get_swap_price(self, buy_token: str, sell_token: str, buy_amount: str) -> str:
+    def get_swap_price(self, buy_token: str, sell_token: str, buy_amount: str, chain: str = "base") -> str:
         """
         Fetches the price for a swap from the 0x Swap API.
 
@@ -75,7 +82,14 @@ class CryptoSwapTools(Toolkit):
             params = {
                 'buyToken': buy_token,
                 'sellToken': sell_token,
-                'buyAmount': buy_amount
+                'buyAmount': buy_amount,
+                'wallet': {
+                    "userEmail": "none",
+                    "chain": chain,
+                    "testnet": True,
+                    "gasless": True,
+                    "connected": True
+                }
             }
             response = asyncio.run(rpc_call(method_name="getSwapPrice", params=params))
             return f"{response}"
@@ -99,35 +113,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.
+        Executes a swap using the 0x Swap API. this is a sensitive function, show a preview and allow user to give final permission to execute function
 
         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')
         """
-        logger.info(f"wap token: buying {buy_token} with {sell_token} amount {sell_amount}")
+
+        logger.info("executing swap")
         try:
             params = {
                 'buyToken': buy_token,
                 'sellToken': sell_token,
                 'sellAmount': sell_amount,
                 'wallet': {
-
+                  "userEmail": user_email,
+                  "chain": chain,
+                  "testnet": True,
+                  "gasless": True,
+                  "connected": True
                 }
             }
             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 swap tokens: {e}")
+            logger.warning(f"Failed to execute swap: {e}")
             # return {"error": str(e)}
             return f"Error: {e}"

src/tools/user_confirmation_pin_toolkit.py

@@ -0,0 +1,107 @@
+import asyncio
+import chainlit as cl
+from phi.tools import Toolkit
+from phi.utils.log import logger
+
+from src.libs.rpc_client import rpc_call
+
+
+class UserConfirmationPinToolkit(Toolkit):
+    def __init__(self):
+        super().__init__(name="user_confirmation_pin_toolkit")
+
+        # Registering methods to make them accessible via the toolkit
+        self.register(self.has_user_confirmation_pin)
+        self.register(self.set_user_confirmation_pin)
+        self.register(self.update_user_confirmation_pin)
+        self.register(self.verify_user_confirmation_pin)
+    
+    def has_user_confirmation_pin(self, user_id: str) -> str:
+        """
+        Checks if a user has a confirmation PIN.
+
+        This method takes a user's ID and checks if the user has a confirmation 
+        PIN via a remote procedure call (RPC).
+
+        Args:
+            user_id (str): The ID of the user to check for a confirmation PIN.
+
+        Returns:
+            str: The response from the RPC call indicating if the user has a PIN.
+        """
+        logger.info("Checking if user has confirmation pin")
+
+        params = {
+            "userId": user_id,
+        }
+        response = asyncio.run(rpc_call(method_name="hasUserPin", params=params))
+        return f"{response}"
+    
+    def set_user_confirmation_pin(self, user_id: str, pin: str) -> str:
+        """
+        Sets a user's confirmation PIN.
+
+        This method takes a user's ID and a new PIN, and sets the user's PIN 
+        via a remote procedure call (RPC).
+
+        Args:
+            user_id (str): The ID of the user whose PIN is to be set.
+            pin (str): The new confirmation PIN to be set.
+
+        Returns:
+            str: The response from the RPC call setting the PIN.
+        """
+        logger.info("Setting user confirmation pin")
+
+        params = {
+            "userId": user_id,
+            "pin": pin
+        }
+        response = asyncio.run(rpc_call(method_name="setUserPin", params=params))
+        return f"{response}"
+    
+    def update_user_confirmation_pin(self, user_id: str, pin: str) -> str:
+        """
+        Updates a user's confirmation PIN.
+
+        This method takes a user's ID and a new PIN, and updates the user's PIN 
+        via a remote procedure call (RPC).
+
+        Args:
+            user_id (str): The ID of the user whose PIN is to be updated.
+            pin (str): The new confirmation PIN to be set.
+
+        Returns:
+            str: The response from the RPC call updating the PIN.
+        """
+        logger.info("Updating user confirmation pin")
+
+        params = {
+            "userId": user_id,
+            "pin": pin
+        }
+        response = asyncio.run(rpc_call(method_name="updateUserPin", params=params))
+        return f"{response}"
+    
+    def verify_user_confirmation_pin(self, user_id: str, pin: str) -> str:
+        """
+        Verifies a user's confirmation PIN.
+
+        This method takes a user's ID and a PIN, converts the email to lowercase,
+        and verifies the PIN via a remote procedure call (RPC).
+
+        Args:
+            user_id (str): The ID of the user whose PIN is to be verified.
+            pin (str): The confirmation PIN to be verified.
+
+        Returns:
+            str: The response from the RPC call verifying the PIN.
+        """
+        logger.info("Verifying user confirmation pin")
+
+        params = {
+            "userId": user_id,
+            "pin": pin
+        }
+        response = asyncio.run(rpc_call(method_name="verifyUserPin", params=params))
+        return f"{response}"

src/tools/user_profile_toolkit.py

@@ -1,7 +1,10 @@
+import asyncio
 import chainlit as cl
 from phi.tools import Toolkit
 from phi.utils.log import logger
 
+from src.libs.rpc_client import rpc_call
+
 
 class UserProfileToolkit(Toolkit):
     def __init__(self):
@@ -16,10 +19,13 @@ 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()
+        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 = "name") -> str:
+    def get_user_info(self, info_type: str) -> str:
         """
         Fetches user information from the Chainlit user session.
 
@@ -164,7 +170,7 @@ class UserProfileToolkit(Toolkit):
         str: Confirmation message.
 
         Example:
-        >>> update_user_email('jane.doe@example.com')
+        >>> update_user_email('jane.doe@chatxbt.com')
         """
         response = self.update_user_info('email', email)
         return f"{response}"
@@ -184,3 +190,24 @@ class UserProfileToolkit(Toolkit):
         """
         response = self.update_user_info('picture', picture)
         return f"{response}"
+    
+    def get_user_id(self, user_email: str) -> str:
+        """
+        Fetches the ChatXBT ID of the user associated with the given email.
+
+        Args:
+        user_email (str): The email address of the user whose ChatXBT ID needs to be fetched.
+
+        Returns:
+        str]: A string containing the ChatXBT ID of the user. If the user is not found, an empty string is returned.
+
+        Example:
+        >>> get_user_id('jane.doe@chatxbt.com')
+        """
+        logger.info("Fetching user ChatXBT ID")
+
+        params = {
+            "userEmail": user_email.lower()
+        }
+        response = asyncio.run(rpc_call(method_name="getUserId", params=params))
+        return f"{response}"