Update app.py

app.py

@@ -55,9 +55,9 @@ BLOCKCHAIN_NODE_URL = st.sidebar.text_input("Blockchain Node URL", value="https:
 # Hardcoded Smart Contract Address
 CONTRACT_ADDRESS = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"  # USDC Token Address
 
-# OpenAI Configuration
+# OpenAI Configuration (Optional)
 st.sidebar.subheader("🤖 OpenAI Configuration")
-OPENAI_API_KEY = st.sidebar.text_input("OpenAI API Key", type="password")
+OPENAI_API_KEY = st.sidebar.text_input("OpenAI API Key (Optional)", type="password")
 
 # ========================
 # Validate Configuration Inputs
@@ -70,34 +70,24 @@ if not BLOCKCHAIN_NODE_URL.startswith("http"):
     config_valid = False
     config_errors.append("Blockchain Node URL must start with http or https.")
 
-if not st.sidebar:
-    config_valid = False
-    config_errors.append("Blockchain Node URL is required.")
-
-if not CONTRACT_ADDRESS.startswith("0x") or len(CONTRACT_ADDRESS) != 42:
+if not (CONTRACT_ADDRESS.startswith("0x") and len(CONTRACT_ADDRESS) == 42):
     config_valid = False
     config_errors.append("Invalid Smart Contract Address.")
 
-if not OPENAI_API_KEY:
-    config_valid = False
-    config_errors.append("OpenAI API Key is required.")
-
-if db_type == "PostgreSQL":
-    if not all([pg_host, pg_port, pg_user, pg_password, pg_db]):
-        config_valid = False
-        config_errors.append("All PostgreSQL configuration fields must be filled.")
-
 if not config_valid:
     st.error("⚠️ **Configuration Errors:**")
     for error in config_errors:
         st.error(f"- {error}")
     st.stop()
 
-# ========================
-# Initialize OpenAI API
-# ========================
-
-openai.api_key = OPENAI_API_KEY
+# Initialize OpenAI API if API key is provided
+if OPENAI_API_KEY:
+    openai.api_key = OPENAI_API_KEY
+    openai_enabled = True
+    st.sidebar.success("🔌 OpenAI Connected")
+else:
+    openai_enabled = False
+    st.sidebar.info("🤖 OpenAI not connected. AI features are disabled.")
 
 # ========================
 # Database Setup
@@ -124,6 +114,7 @@ class Token(Base):
     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
     verified = Column(Boolean, default=False)
     verification_hash = Column(String(64))
     created_at = Column(DateTime, default=datetime.utcnow)
@@ -204,6 +195,8 @@ def calculate_token_grade(ai_output):
     Sends AI output back to AI to grade it based on a predefined rubric.
     Returns the grade which determines the number of tokens.
     """
+    if not openai_enabled:
+        return 0  # No grading if OpenAI is not enabled
     try:
         # Define the grading rubric as a prompt
         grading_prompt = f"""
@@ -239,6 +232,8 @@ def process_ai(input_text):
     """
     Processes input text using OpenAI's GPT-4 API.
     """
+    if not openai_enabled:
+        return "❌ OpenAI is not configured. Please provide an OpenAI API Key to use AI features."
     try:
         response = openai.Completion.create(
             engine="text-davinci-003",  # Use 'gpt-4' if available
@@ -296,75 +291,88 @@ if authentication_status:
     col1.metric("Tokens", f"{user.balance:.2f}")
     col2.metric("Staked Tokens", f"{user.staked:.2f}")
     
-    # Create Tabs
-    tabs = st.tabs(["AI Query", "Token Management", "Staking", "Trading", "Transaction History", "Chat", "About Me"])
+    # 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
+    # AI Query Submission (Optional)
     # ========================
-    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)
+    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:
-                    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
-                                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}")
-                        else:
-                            st.error(f"❌ Token minting failed: {mint_response}")
+                    with st.spinner("🔍 Processing your AI query..."):
+                        ai_output = process_ai(input_text)
+                    if ai_output.startswith("❌"):
+                        st.error(ai_output)
                     else:
-                        st.error("❌ Token amount determined as zero. Please try again.")
+                        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}")
+                        else:
+                            st.error("❌ Token amount determined as zero. Please try again.")
     
     # ========================
     # Token Management
     # ========================
-    with tabs[1]:
+    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:
@@ -373,6 +381,7 @@ if authentication_status:
                 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",
@@ -386,7 +395,8 @@ if authentication_status:
     # ========================
     # Staking
     # ========================
-    with tabs[2]:
+    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)
@@ -421,7 +431,8 @@ if authentication_status:
     # ========================
     # Trading
     # ========================
-    with tabs[3]:
+    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")
@@ -463,7 +474,8 @@ if authentication_status:
     # ========================
     # Transaction History
     # ========================
-    with tabs[4]:
+    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:
@@ -481,51 +493,54 @@ if authentication_status:
             st.write("📭 No transactions found.")
     
     # ========================
-    # Chat Interface
+    # Chat Interface (Optional)
     # ========================
-    with tabs[5]:
-        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 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 AI:** {message}")
+    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 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 AI:** {message}")
     
     # ========================
     # About Me Tab
     # ========================
-    with tabs[6]:
+    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
@@ -533,14 +548,14 @@ if authentication_status:
 
         ### 🚀 Features
         - **User Authentication:** Secure registration and login system with hashed passwords.
-        - **AI Query Submission:** Submit queries to the AI and receive insightful responses.
-        - **AI Grading Mechanism:** AI evaluates its own outputs based on a predefined rubric to determine token rewards.
+        - **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.
+        - **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
@@ -548,7 +563,7 @@ if authentication_status:
         - **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
+        - **AI Services:** OpenAI GPT-4 API *(Optional)*
 
         ### 🔒 Security
         - **Password Hashing:** User passwords are securely hashed using industry-standard algorithms.
@@ -574,8 +589,8 @@ if authentication_status:
     
     st.sidebar.header("🪙 Mint Token")
     with st.sidebar.form("mint_token_form"):
-        mint_address = st.text_input("Recipient Address (0x...)")
-        mint_text = st.text_input("Mint Text")
+        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:
@@ -584,7 +599,7 @@ if authentication_status:
         elif not (mint_address.startswith("0x") and len(mint_address) == 42):
             st.sidebar.error("❌ Invalid Blockchain Address format.")
         else:
-            with st.spinner("🔍 Minting tokens and storing text..."):
+            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
@@ -600,6 +615,7 @@ if authentication_status:
                         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()
                     )