Update app.py

app.py

@@ -12,15 +12,12 @@ import time
 from datetime import datetime, timedelta
 
 import streamlit as st
-import streamlit_authenticator as stauth
 import requests
 
 from sqlalchemy import create_engine, Column, Integer, String, Float, Boolean, DateTime, ForeignKey
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker, relationship
 
-from werkzeug.security import generate_password_hash, check_password_hash
-
 import openai
 
 # ========================
@@ -100,23 +97,10 @@ else:
 
 Base = declarative_base()
 
-class User(Base):
-    __tablename__ = 'users'
-    
-    id = Column(Integer, primary_key=True)
-    username = Column(String(80), unique=True, nullable=False)
-    password = Column(String(200), nullable=False)
-    balance = Column(Float, default=0.0)
-    staked = Column(Float, default=0.0)
-    blockchain_address = Column(String(42), unique=True, nullable=False)  # Ethereum address
-    tokens = relationship('Token', backref='owner', lazy=True)
-    transactions = relationship('Transaction', backref='user', lazy=True)
-
 class Token(Base):
     __tablename__ = 'tokens'
     
     id = Column(String(36), primary_key=True)  # UUID
-    owner_id = Column(Integer, ForeignKey('users.id'), nullable=False)
     value = Column(Float, nullable=False)
     text = Column(String(256), nullable=False)  # Text to store on blockchain
     recipient_address = Column(String(42), nullable=False)  # Address receiving tokens
@@ -128,7 +112,6 @@ class Transaction(Base):
     __tablename__ = 'transactions'
     
     id = Column(Integer, primary_key=True)
-    user_id = Column(Integer, ForeignKey('users.id'), nullable=False)
     token_id = Column(String(36), ForeignKey('tokens.id'), nullable=True)
     action = Column(String(50), nullable=False)
     value = Column(Float, nullable=True)
@@ -139,7 +122,6 @@ class Stake(Base):
     __tablename__ = 'stakes'
     
     id = Column(Integer, primary_key=True)
-    user_id = Column(Integer, ForeignKey('users.id'), nullable=False)
     amount = Column(Float, nullable=False)
     timestamp = Column(DateTime, default=datetime.utcnow)
 
@@ -254,440 +236,365 @@ def process_ai(input_text):
         return f"❌ Error processing AI output: {str(e)}"
 
 # ========================
-# Streamlit Authentication Setup
+# Initialize Application State
 # ========================
 
-# Fetch users from the database
-users = session.query(User).all()
-
-# Build the credentials dictionary
-credentials = {
-    "usernames": {
-        user.username: {
-            "name": user.username,       # You can customize this if you have a separate name field
-            "password": user.password    # This should be the hashed password
-        }
-        for user in users
-    }
-}
+# For the purpose of this version without user authentication,
+# we'll manage a single global balance and staked tokens.
+# In a multi-user scenario, this should be adjusted accordingly.
 
-# If no users are present, ensure 'usernames' is an empty dictionary
-if not users:
-    credentials = {"usernames": {}}
+if 'balance' not in st.session_state:
+    st.session_state.balance = 0.0
 
-# Debugging: Display credentials structure (Remove or comment out in production)
-# st.write("Credentials Structure:", credentials)
+if 'staked' not in st.session_state:
+    st.session_state.staked = 0.0
 
-# Initialize Authenticator with keyword arguments
-authenticator = stauth.Authenticate(
-    credentials,
-    'citibank_demo_business_inc_ai_crypto',  # cookie_name
-    'abcdef',                                 # key
-    cookie_expiry_days=1                      # cookie_expiry_days
-)
+# ========================
+# User Dashboard with Tabs
+# ========================
 
-name, authentication_status, username = authenticator.login('Login', 'main')
+st.header("🌟 Dashboard 🌟")
 
-if authentication_status:
-    st.sidebar.success(f"Welcome *{name}*")
-    authenticator.logout('Logout', 'sidebar')
-    
-    # ========================
-    # User Dashboard with Tabs
-    # ========================
-    
-    st.header("🌟 Dashboard 🌟")
-    
-    # Fetch user data
-    user = session.query(User).filter_by(username=username).first()
-    
-    # Display Balance
-    st.subheader("💰 Your Balance")
-    col1, col2 = st.columns(2)
-    col1.metric("Tokens", f"{user.balance:.2f}")
-    col2.metric("Staked Tokens", f"{user.staked:.2f}")
-    
-    # Create Tabs based on OpenAI configuration
-    tabs_titles = ["Token Management", "Staking", "Trading", "Transaction History"]
-    if openai_enabled:
-        tabs_titles.insert(0, "AI Query")
-        tabs_titles.append("Chat")
-    
-    tabs_titles.append("About Me")
-    
-    tabs = st.tabs(tabs_titles)
-    
-    # ========================
-    # AI Query Submission (Optional)
-    # ========================
-    if openai_enabled:
-        with tabs[0]:
-            st.subheader("🤖 Submit AI Query")
-            with st.form("ai_query_form"):
-                input_text = st.text_area("Enter your query here...", height=100)
-                submit_button = st.form_submit_button(label='Submit')
-            
-            if submit_button:
-                if input_text.strip() == "":
-                    st.error("❌ Input text cannot be empty.")
+# Display Balance
+st.subheader("💰 Balance")
+col1, col2 = st.columns(2)
+col1.metric("Tokens", f"{st.session_state.balance:.2f}")
+col2.metric("Staked Tokens", f"{st.session_state.staked:.2f}")
+
+# Create Tabs based on OpenAI configuration
+tabs_titles = ["Token Management", "Staking", "Trading", "Transaction History"]
+if openai_enabled:
+    tabs_titles.insert(0, "AI Query")
+    tabs_titles.append("Chat")
+
+tabs_titles.append("About")
+
+tabs = st.tabs(tabs_titles)
+
+# ========================
+# AI Query Submission (Optional)
+# ========================
+if openai_enabled:
+    with tabs[0]:
+        st.subheader("🤖 Submit AI Query")
+        with st.form("ai_query_form"):
+            input_text = st.text_area("Enter your query here...", height=100)
+            submit_button = st.form_submit_button(label='Submit')
+        
+        if submit_button:
+            if input_text.strip() == "":
+                st.error("❌ Input text cannot be empty.")
+            else:
+                with st.spinner("🔍 Processing your AI query..."):
+                    ai_output = process_ai(input_text)
+                if ai_output.startswith("❌"):
+                    st.error(ai_output)
                 else:
-                    with st.spinner("🔍 Processing your AI query..."):
-                        ai_output = process_ai(input_text)
-                    if ai_output.startswith("❌"):
-                        st.error(ai_output)
-                    else:
-                        st.success("✅ AI Query Processed!")
-                        st.write(f"**AI Output:** {ai_output}")
-                        # Grade AI Output
-                        token_amount = calculate_token_grade(ai_output)
-                        if token_amount > 0:
-                            # Mint Token via API
-                            token_address = user.blockchain_address
-                            token_contract = CONTRACT_ADDRESS  # Using hardcoded contract address
-                            balance = "100"  # Adjust as needed
-                            mint_success, mint_response = mint_tokens_via_api(token_address, token_contract, balance)
-                            if mint_success:
-                                st.success("✅ Token minted successfully via API!")
-                                st.write(f"**API Response:** {json.dumps(mint_response, indent=2)}")
-                                # Update local database
-                                token = Token(
-                                    id=str(uuid.uuid4()),
-                                    owner_id=user.id,
-                                    value=token_amount,
-                                    text=input_text,  # Store the input text
-                                    recipient_address=token_address,
-                                    verified=False,
-                                    verification_hash=hashlib.sha256(ai_output.encode()).hexdigest()
-                                )
-                                session.add(token)
-                                session.commit()
-                                # Update user's balance
-                                user.balance += token_amount
-                                session.commit()
-                                # Record transaction
-                                transaction = Transaction(
-                                    user_id=user.id,
-                                    token_id=token.id,
-                                    action='minted',
-                                    value=token_amount,
-                                    hash=token.verification_hash
-                                )
-                                session.add(transaction)
-                                session.commit()
-                                st.write(f"**Token ID:** {token.id}")
-                                st.write(f"**Tokens Earned:** {token_amount:.2f}")
-                                st.write(f"**Stored Text:** {token.text}")
-                            else:
-                                st.error(f"❌ Token minting failed: {mint_response}")
+                    st.success("✅ AI Query Processed!")
+                    st.write(f"**AI Output:** {ai_output}")
+                    # Grade AI Output
+                    token_amount = calculate_token_grade(ai_output)
+                    if token_amount > 0:
+                        # Mint Token via API
+                        token_address = "0xYourDefaultAddressHere"  # Replace with a default or configurable address
+                        token_contract = CONTRACT_ADDRESS  # Using hardcoded contract address
+                        balance = "100"  # Adjust as needed
+                        mint_success, mint_response = mint_tokens_via_api(token_address, token_contract, balance)
+                        if mint_success:
+                            st.success("✅ Token minted successfully via API!")
+                            st.write(f"**API Response:** {json.dumps(mint_response, indent=2)}")
+                            # Update local database
+                            token = Token(
+                                id=str(uuid.uuid4()),
+                                value=token_amount,
+                                text=input_text,  # Store the input text
+                                recipient_address=token_address,
+                                verified=False,
+                                verification_hash=hashlib.sha256(ai_output.encode()).hexdigest()
+                            )
+                            session.add(token)
+                            session.commit()
+                            # Update session state balance
+                            st.session_state.balance += token_amount
+                            # Record transaction
+                            transaction = Transaction(
+                                token_id=token.id,
+                                action='minted',
+                                value=token_amount,
+                                hash=token.verification_hash
+                            )
+                            session.add(transaction)
+                            session.commit()
+                            st.write(f"**Token ID:** {token.id}")
+                            st.write(f"**Tokens Earned:** {token_amount:.2f}")
+                            st.write(f"**Stored Text:** {token.text}")
                         else:
-                            st.error("❌ Token amount determined as zero. Please try again.")
+                            st.error(f"❌ Token minting failed: {mint_response}")
+                    else:
+                        st.error("❌ Token amount determined as zero. Please try again.")
+
+# ========================
+# Token Management
+# ========================
+token_tab_index = 0
+if openai_enabled:
+    token_tab_index = 1
+with tabs[token_tab_index]:
+    st.subheader("🪙 Tokens")
+    tokens = session.query(Token).all()
+    if tokens:
+        token_data = []
+        for token in tokens:
+            token_info = {
+                "Token ID": token.id,
+                "Value": f"{token.value:.2f}",
+                "Recipient Address": token.recipient_address,
+                "Text": token.text,
+                "Verified": "Yes" if token.verified else "No",
+                "Verification Hash": token.verification_hash or "N/A",
+                "Created At": token.created_at.strftime('%Y-%m-%d %H:%M:%S')
+            }
+            token_data.append(token_info)
+        st.table(token_data)
+    else:
+        st.write("📭 No tokens found.")
+
+# ========================
+# Staking
+# ========================
+staking_tab_index = token_tab_index + 1
+with tabs[staking_tab_index]:
+    st.subheader("📈 Stake Tokens")
+    with st.form("stake_form"):
+        stake_amount = st.number_input("Amount to Stake", min_value=0.0, step=1.0)
+        stake_button = st.form_submit_button(label='Stake Tokens')
     
-    # ========================
-    # Token Management
-    # ========================
-    token_tab_index = 0
-    if openai_enabled:
-        token_tab_index = 1
-    with tabs[token_tab_index]:
-        st.subheader("🪙 Your Tokens")
-        tokens = session.query(Token).filter_by(owner_id=user.id).all()
-        if tokens:
-            token_data = []
-            for token in tokens:
-                token_info = {
-                    "Token ID": token.id,
-                    "Value": f"{token.value:.2f}",
-                    "Recipient Address": token.recipient_address,
-                    "Text": token.text,
-                    "Verified": "Yes" if token.verified else "No",
-                    "Verification Hash": token.verification_hash or "N/A",
-                    "Created At": token.created_at.strftime('%Y-%m-%d %H:%M:%S')
-                }
-                token_data.append(token_info)
-            st.table(token_data)
+    if stake_button:
+        if stake_amount <= 0:
+            st.error("❌ Stake amount must be greater than zero.")
+        elif st.session_state.balance < stake_amount:
+            st.error("❌ Insufficient balance.")
         else:
-            st.write("📭 You have no tokens yet.")
+            st.session_state.balance -= stake_amount
+            st.session_state.staked += stake_amount
+            stake = Stake(
+                amount=stake_amount
+            )
+            session.add(stake)
+            session.commit()
+            # Record transaction
+            transaction = Transaction(
+                action='stake',
+                value=stake_amount
+            )
+            session.add(transaction)
+            session.commit()
+            st.success("✅ Staked successfully.")
+            st.write(f"**New Balance:** {st.session_state.balance:.2f}")
+            st.write(f"**Total Staked:** {st.session_state.staked:.2f}")
+
+# ========================
+# Trading
+# ========================
+trading_tab_index = staking_tab_index + 1
+with tabs[trading_tab_index]:
+    st.subheader("🔄 Trade Tokens")
+    with st.form("trade_form"):
+        seller_address = st.text_input("Seller Blockchain Address (0x...)")
+        token_id = st.text_input("Token ID")
+        trade_button = st.form_submit_button(label='Trade Token')
     
-    # ========================
-    # Staking
-    # ========================
-    staking_tab_index = token_tab_index + 1
-    with tabs[staking_tab_index]:
-        st.subheader("📈 Stake Tokens")
-        with st.form("stake_form"):
-            stake_amount = st.number_input("Amount to Stake", min_value=0.0, step=1.0)
-            stake_button = st.form_submit_button(label='Stake Tokens')
-        
-        if stake_button:
-            if stake_amount <= 0:
-                st.error("❌ Stake amount must be greater than zero.")
-            elif user.balance < stake_amount:
-                st.error("❌ Insufficient balance.")
+    if trade_button:
+        if seller_address.strip() == "" or token_id.strip() == "":
+            st.error("❌ Seller address and Token ID are required.")
+        elif not (seller_address.startswith("0x") and len(seller_address) == 42):
+            st.error("❌ Invalid Blockchain Address format.")
+        else:
+            token = session.query(Token).filter_by(id=token_id, recipient_address=seller_address).first()
+            if not token:
+                st.error("❌ Token not found or unauthorized.")
             else:
-                user.balance -= stake_amount
-                user.staked += stake_amount
-                stake = Stake(
-                    user_id=user.id,
-                    amount=stake_amount
-                )
-                session.add(stake)
+                # Transfer ownership by updating recipient address
+                token.recipient_address = "0xYourDefaultAddressHere"  # Replace with your address or handle accordingly
                 session.commit()
+                # Update session state balance
+                st.session_state.balance += token.value
                 # Record transaction
                 transaction = Transaction(
-                    user_id=user.id,
-                    action='stake',
-                    value=stake_amount
+                    token_id=token.id,
+                    action='trade',
+                    value=token.value
                 )
                 session.add(transaction)
                 session.commit()
-                st.success("✅ Staked successfully.")
-                st.write(f"**New Balance:** {user.balance:.2f}")
-                st.write(f"**Total Staked:** {user.staked:.2f}")
-    
-    # ========================
-    # Trading
-    # ========================
-    trading_tab_index = staking_tab_index + 1
-    with tabs[trading_tab_index]:
-        st.subheader("🔄 Trade Tokens")
-        with st.form("trade_form"):
-            seller_username = st.text_input("Seller Username")
-            token_id = st.text_input("Token ID")
-            trade_button = st.form_submit_button(label='Trade Token')
+                st.success("✅ Trade successful.")
+                st.write(f"**New Balance:** {st.session_state.balance:.2f}")
+                st.write(f"**Token Value:** {token.value:.2f}")
+
+# ========================
+# Transaction History
+# ========================
+transaction_history_tab_index = trading_tab_index + 1
+with tabs[transaction_history_tab_index]:
+    st.subheader("📜 Transaction History")
+    transactions = session.query(Transaction).order_by(Transaction.timestamp.desc()).all()
+    if transactions:
+        transaction_data = []
+        for tx in transactions:
+            tx_info = {
+                "Action": tx.action,
+                "Value": f"{tx.value:.2f}" if tx.value else "N/A",
+                "Hash": tx.hash or "N/A",
+                "Timestamp": tx.timestamp.strftime('%Y-%m-%d %H:%M:%S')
+            }
+            transaction_data.append(tx_info)
+        st.table(transaction_data)
+    else:
+        st.write("📭 No transactions found.")
+
+# ========================
+# Chat Interface (Optional)
+# ========================
+if openai_enabled:
+    chat_tab_index = transaction_history_tab_index + 1
+    with tabs[chat_tab_index]:
+        st.subheader("💬 Chat with CITIBANK DEMO BUSINESS INC AI")
+        if 'chat_history' not in st.session_state:
+            st.session_state['chat_history'] = []
+        
+        def get_ai_response(user_input):
+            """
+            Generate AI response using OpenAI.
+            """
+            try:
+                response = openai.Completion.create(
+                    engine="text-davinci-003",  # Use 'gpt-4' if available
+                    prompt=user_input,
+                    max_tokens=150,
+                    temperature=0.7,
+                    n=1,
+                    stop=None
+                )
+                ai_output = response.choices[0].text.strip()
+                return ai_output
+            except Exception as e:
+                return f"❌ Error processing AI output: {str(e)}"
+        
+        user_input = st.text_input("You:", key="chat_input")
         
-        if trade_button:
-            if seller_username.strip() == "" or token_id.strip() == "":
-                st.error("❌ Seller username and Token ID are required.")
+        if st.button("Send"):
+            if user_input.strip() == "":
+                st.warning("❌ Please enter a message.")
             else:
-                seller = session.query(User).filter_by(username=seller_username).first()
-                if not seller:
-                    st.error("❌ Seller not found.")
-                else:
-                    token = session.query(Token).filter_by(id=token_id, owner_id=seller.id).first()
-                    if not token:
-                        st.error("❌ Token not found or unauthorized.")
-                    else:
-                        # Transfer ownership
-                        token.owner_id = user.id
-                        session.commit()
-                        # Update balances
-                        seller.balance -= token.value
-                        user.balance += token.value
-                        session.commit()
-                        # Record transaction
-                        transaction = Transaction(
-                            user_id=user.id,
-                            token_id=token.id,
-                            action='trade',
-                            value=token.value
-                        )
-                        session.add(transaction)
-                        session.commit()
-                        st.success("✅ Trade successful.")
-                        st.write(f"**New Balance:** {user.balance:.2f}")
-                        st.write(f"**Token Value:** {token.value:.2f}")
-    
-    # ========================
-    # Transaction History
-    # ========================
-    transaction_history_tab_index = trading_tab_index + 1
-    with tabs[transaction_history_tab_index]:
-        st.subheader("📜 Transaction History")
-        transactions = session.query(Transaction).filter_by(user_id=user.id).order_by(Transaction.timestamp.desc()).all()
-        if transactions:
-            transaction_data = []
-            for tx in transactions:
-                tx_info = {
-                    "Action": tx.action,
-                    "Value": f"{tx.value:.2f}" if tx.value else "N/A",
-                    "Hash": tx.hash or "N/A",
-                    "Timestamp": tx.timestamp.strftime('%Y-%m-%d %H:%M:%S')
-                }
-                transaction_data.append(tx_info)
-            st.table(transaction_data)
-        else:
-            st.write("📭 No transactions found.")
-    
-    # ========================
-    # Chat Interface (Optional)
-    # ========================
-    if openai_enabled:
-        chat_tab_index = transaction_history_tab_index + 1
-        with tabs[chat_tab_index]:
-            st.subheader("💬 Chat with CITIBANK DEMO BUSINESS INC AI")
-            if 'chat_history' not in st.session_state:
-                st.session_state['chat_history'] = []
-            
-            def get_ai_response(user_input):
-                """
-                Generate AI response using OpenAI.
-                """
-                try:
-                    response = openai.Completion.create(
-                        engine="text-davinci-003",  # Use 'gpt-4' if available
-                        prompt=user_input,
-                        max_tokens=150,
-                        temperature=0.7,
-                        n=1,
-                        stop=None
-                    )
-                    ai_output = response.choices[0].text.strip()
-                    return ai_output
-                except Exception as e:
-                    return f"❌ Error processing AI output: {str(e)}"
-            
-            user_input = st.text_input("You:", key="chat_input")
-            
-            if st.button("Send"):
-                if user_input.strip() == "":
-                    st.warning("❌ Please enter a message.")
-                else:
-                    st.session_state.chat_history.append(("You", user_input))
-                    ai_response = get_ai_response(user_input)
-                    st.session_state.chat_history.append(("CITIBANK DEMO BUSINESS INC AI", ai_response))
-            
-            for sender, message in st.session_state.chat_history:
-                if sender == "You":
-                    st.markdown(f"**You:** {message}")
-                else:
-                    st.markdown(f"**CITIBANK DEMO BUSINESS INC AI:** {message}")
-    
-    # ========================
-    # About Me Tab
-    # ========================
-    about_me_tab_index = transaction_history_tab_index + (2 if openai_enabled else 1)
-    with tabs[about_me_tab_index]:
-        st.subheader("ℹ️ About CITIBANK DEMO BUSINESS INC AI Crypto Ecosystem")
-        st.markdown("""
-        ### 🌟 Overview
-        The **CITIBANK DEMO BUSINESS INC AI Crypto Ecosystem** is a cutting-edge platform that seamlessly integrates **Artificial Intelligence** with **Blockchain Technology** to create a **self-sustaining** and **monetizable** ecosystem. This system empowers users to interact with AI services, earn and manage cryptocurrency tokens, and participate in a transparent and decentralized economy.
-
-        ### 🚀 Features
-        - **User Authentication:** Secure registration and login system with hashed passwords.
-        - **AI Query Submission:** Submit queries to the AI and receive insightful responses. *(Requires OpenAI API Key)*
-        - **AI Grading Mechanism:** AI evaluates its own outputs based on a predefined rubric to determine token rewards. *(Requires OpenAI API Key)*
-        - **Token Minting:** Earn tokens based on the AI-generated content's quality.
-        - **Token Management:** View and manage your tokens, including verification status.
-        - **Staking:** Stake your tokens to earn rewards and support the ecosystem.
-        - **Trading:** Trade tokens with other users within the ecosystem.
-        - **Transaction History:** Transparent logs of all your activities.
-        - **Chat Interface:** Interact with the AI through a dedicated chat box. *(Requires OpenAI API Key)*
-        - **About Section:** Detailed information about the ecosystem and its functionalities.
-
-        ### 🛠️ Technology Stack
-        - **Backend:** Streamlit, SQLAlchemy
-        - **Frontend:** Streamlit Interface with Tabs
-        - **Blockchain:** Solidity, Ethereum (or any EVM-compatible blockchain)
-        - **Database:** SQLite (for demonstration) or PostgreSQL (for production)
-        - **AI Services:** OpenAI GPT-4 API *(Optional)*
-
-        ### 🔒 Security
-        - **Password Hashing:** User passwords are securely hashed using industry-standard algorithms.
-        - **Input Validation:** Comprehensive validation to prevent vulnerabilities like SQL injection and XSS attacks.
-        - **Secure Data Handling:** Sensitive information such as API keys are managed securely within the application interface.
-
-        ### 🌐 Deployment
-        The application is optimized for deployment on **Hugging Face Spaces**, ensuring accessibility and scalability. Users can configure all necessary settings directly through the Streamlit interface, eliminating the need for external environment variables.
-
-        ### 📈 Scalability
-        - **Modular Design:** Each component is isolated, allowing for independent scaling and maintenance.
-        - **Efficient Database Management:** Utilizing SQLAlchemy for optimized interactions.
-        - **Asynchronous Processing:** Background threads handle long-running tasks without blocking the main application.
-        - **Optimized API Interactions:** Efficient handling of API requests to manage high volumes of token minting.
-
-        ---
-        *Embark on this transformative journey with **CITIBANK DEMO BUSINESS INC** to redefine the synergy between AI and blockchain, creating an unparalleled decentralized economy.*
-        """)
-
-    # ========================
-    # Mint Token Functionality
-    # ========================
-    
-    st.sidebar.header("🪙 Mint Token")
-    with st.sidebar.form("mint_token_form"):
-        mint_address = st.text_input("Recipient Address (0x...)", value="")
-        mint_text = st.text_input("Mint Text", value="")
-        mint_button = st.form_submit_button(label='Mint Token')
-    
-    if mint_button:
-        if not mint_address or not mint_text:
-            st.sidebar.error("❌ Both Address and Text are required.")
-        elif not (mint_address.startswith("0x") and len(mint_address) == 42):
-            st.sidebar.error("❌ Invalid Blockchain Address format.")
-        else:
-            with st.sidebar.spinner("🔍 Minting tokens and storing text..."):
-                # Mint tokens via external API
-                token_contract = CONTRACT_ADDRESS  # Using hardcoded contract address
-                balance = "100"  # Adjust as needed or make it dynamic
-                mint_success, mint_response = mint_tokens_via_api(mint_address, token_contract, balance)
-                
-                if mint_success:
-                    st.sidebar.success("✅ Token minted successfully via API!")
-                    st.sidebar.write(f"**API Response:** {json.dumps(mint_response, indent=2)}")
-                    
-                    # Update local database
-                    token = Token(
-                        id=str(uuid.uuid4()),
-                        owner_id=user.id,
-                        value=100.0,  # Assuming balance is 100 tokens
-                        text=mint_text,  # Store the input text
-                        recipient_address=mint_address,
-                        verified=False,
-                        verification_hash=hashlib.sha256(mint_text.encode()).hexdigest()
-                    )
-                    session.add(token)
-                    session.commit()
-                    
-                    # Update user's balance
-                    user.balance += token.value
-                    session.commit()
-                    
-                    # Record transaction
-                    transaction = Transaction(
-                        user_id=user.id,
-                        token_id=token.id,
-                        action='minted',
-                        value=token.value,
-                        hash=token.verification_hash
-                    )
-                    session.add(transaction)
-                    session.commit()
-                    
-                    st.sidebar.write(f"**Token ID:** {token.id}")
-                    st.sidebar.write(f"**Tokens Earned:** {token.value:.2f}")
-                    st.sidebar.write(f"**Stored Text:** {token.text}")
-                else:
-                    st.sidebar.error(f"❌ Token minting failed: {mint_response}")
-
-elif authentication_status == False:
-    st.error('❌ Username/password is incorrect')
+                st.session_state.chat_history.append(("You", user_input))
+                ai_response = get_ai_response(user_input)
+                st.session_state.chat_history.append(("CITIBANK DEMO BUSINESS INC AI", ai_response))
+        
+        for sender, message in st.session_state.chat_history:
+            if sender == "You":
+                st.markdown(f"**You:** {message}")
+            else:
+                st.markdown(f"**CITIBANK DEMO BUSINESS INC AI:** {message}")
 
-elif authentication_status == None:
-    st.warning('⚠️ Please enter your username and password')
+# ========================
+# About Me Tab
+# ========================
+about_me_tab_index = transaction_history_tab_index + (2 if openai_enabled else 1)
+with tabs[about_me_tab_index]:
+    st.subheader("ℹ️ About CITIBANK DEMO BUSINESS INC AI Crypto Ecosystem")
+    st.markdown("""
+    ### 🌟 Overview
+    The **CITIBANK DEMO BUSINESS INC AI Crypto Ecosystem** is a cutting-edge platform that seamlessly integrates **Artificial Intelligence** with **Blockchain Technology** to create a **self-sustaining** and **monetizable** ecosystem. This system empowers users to interact with AI services, earn and manage cryptocurrency tokens, and participate in a transparent and decentralized economy.
+
+    ### 🚀 Features
+    - **AI Query Submission:** Submit queries to the AI and receive insightful responses. *(Requires OpenAI API Key)*
+    - **AI Grading Mechanism:** AI evaluates its own outputs based on a predefined rubric to determine token rewards. *(Requires OpenAI API Key)*
+    - **Token Minting:** Earn tokens based on the AI-generated content's quality.
+    - **Token Management:** View and manage your tokens, including verification status.
+    - **Staking:** Stake your tokens to earn rewards and support the ecosystem.
+    - **Trading:** Trade tokens within the ecosystem.
+    - **Transaction History:** Transparent logs of all your activities.
+    - **Chat Interface:** Interact with the AI through a dedicated chat box. *(Requires OpenAI API Key)*
+    - **About Section:** Detailed information about the ecosystem and its functionalities.
+
+    ### 🛠️ Technology Stack
+    - **Backend:** Streamlit, SQLAlchemy
+    - **Frontend:** Streamlit Interface with Tabs
+    - **Blockchain:** Solidity, Ethereum (or any EVM-compatible blockchain)
+    - **Database:** SQLite (for demonstration) or PostgreSQL (for production)
+    - **AI Services:** OpenAI GPT-4 API *(Optional)*
+
+    ### 🔒 Security
+    - **Input Validation:** Comprehensive validation to prevent vulnerabilities like SQL injection and XSS attacks.
+    - **Secure Data Handling:** Sensitive information such as API keys are managed securely within the application interface.
+
+    ### 🌐 Deployment
+    The application is optimized for deployment on **Hugging Face Spaces**, ensuring accessibility and scalability. Users can configure all necessary settings directly through the Streamlit interface, eliminating the need for external environment variables.
+
+    ### 📈 Scalability
+    - **Modular Design:** Each component is isolated, allowing for independent scaling and maintenance.
+    - **Efficient Database Management:** Utilizing SQLAlchemy for optimized interactions.
+    - **Asynchronous Processing:** Background threads handle long-running tasks without blocking the main application.
+    - **Optimized API Interactions:** Efficient handling of API requests to manage high volumes of token minting.
+
+    ---
+    *Embark on this transformative journey with **CITIBANK DEMO BUSINESS INC** to redefine the synergy between AI and blockchain, creating an unparalleled decentralized economy.*
+    """)
 
 # ========================
-# User Registration
+# Mint Token Functionality
 # ========================
 
-st.sidebar.subheader("📢 Register New User")
-with st.sidebar.form("register_form"):
-    new_username = st.text_input("New Username")
-    new_password = st.text_input("New Password", type="password")
-    blockchain_address = st.text_input("Blockchain Address (0x...)")
-    register_button = st.form_submit_button(label='Register')
-
-if register_button:
-    if not new_username or not new_password or not blockchain_address:
-        st.sidebar.error("❌ All fields are required.")
-    elif not (blockchain_address.startswith("0x") and len(blockchain_address) == 42):
+st.sidebar.header("🪙 Mint Token")
+with st.sidebar.form("mint_token_form"):
+    mint_address = st.text_input("Recipient Address (0x...)", value="")
+    mint_text = st.text_input("Mint Text", value="")
+    mint_button = st.form_submit_button(label='Mint Token')
+
+if mint_button:
+    if not mint_address or not mint_text:
+        st.sidebar.error("❌ Both Address and Text are required.")
+    elif not (mint_address.startswith("0x") and len(mint_address) == 42):
         st.sidebar.error("❌ Invalid Blockchain Address format.")
-    elif session.query(User).filter_by(username=new_username).first():
-        st.sidebar.error("❌ Username already exists.")
-    elif session.query(User).filter_by(blockchain_address=blockchain_address).first():
-        st.sidebar.error("❌ Blockchain address already in use.")
     else:
-        hashed_password = generate_password_hash(new_password)
-        new_user = User(username=new_username, password=hashed_password, blockchain_address=blockchain_address)
-        session.add(new_user)
-        session.commit()
-        st.sidebar.success("✅ User registered successfully!")
+        with st.sidebar.spinner("🔍 Minting tokens and storing text..."):
+            # Mint tokens via external API
+            token_contract = CONTRACT_ADDRESS  # Using hardcoded contract address
+            balance = "100"  # Adjust as needed or make it dynamic
+            mint_success, mint_response = mint_tokens_via_api(mint_address, token_contract, balance)
+            
+            if mint_success:
+                st.sidebar.success("✅ Token minted successfully via API!")
+                st.sidebar.write(f"**API Response:** {json.dumps(mint_response, indent=2)}")
+                
+                # Update local database
+                token = Token(
+                    id=str(uuid.uuid4()),
+                    value=100.0,  # Assuming balance is 100 tokens
+                    text=mint_text,  # Store the input text
+                    recipient_address=mint_address,
+                    verified=False,
+                    verification_hash=hashlib.sha256(mint_text.encode()).hexdigest()
+                )
+                session.add(token)
+                session.commit()
+                
+                # Update session state balance
+                st.session_state.balance += token.value
+                session.commit()
+                
+                # Record transaction
+                transaction = Transaction(
+                    token_id=token.id,
+                    action='minted',
+                    value=token.value,
+                    hash=token.verification_hash
+                )
+                session.add(transaction)
+                session.commit()
+                
+                st.sidebar.write(f"**Token ID:** {token.id}")
+                st.sidebar.write(f"**Tokens Earned:** {token.value:.2f}")
+                st.sidebar.write(f"**Stored Text:** {token.text}")
+            else:
+                st.sidebar.error(f"❌ Token minting failed: {mint_response}")