Update app.py

app.py

@@ -69,7 +69,7 @@ if not BLOCKCHAIN_NODE_URL.startswith("http"):
     config_valid = False
     config_errors.append("Blockchain Node URL must start with http or https.")
 
-if not Web3.isAddress(CONTRACT_ADDRESS):
+if not Web3.is_address(CONTRACT_ADDRESS):
     config_valid = False
     config_errors.append("Invalid Smart Contract Address.")
 
@@ -112,6 +112,7 @@ class User(Base):
     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)  # Added blockchain address
     tokens = relationship('Token', backref='owner', lazy=True)
     transactions = relationship('Transaction', backref='user', lazy=True)
 
@@ -319,12 +320,12 @@ passwords = [user.password for user in users]
 if users:
     authenticator = stauth.Authenticate(
         names, usernames, passwords,
-        'citibank_ai_crypto', 'abcdef', cookie_expiry_days=1
+        'citibank_demo_business_inc_ai_crypto', 'abcdef', cookie_expiry_days=1
     )
 else:
     authenticator = stauth.Authenticate(
         [], [], [],
-        'citibank_ai_crypto', 'abcdef', cookie_expiry_days=1
+        'citibank_demo_business_inc_ai_crypto', 'abcdef', cookie_expiry_days=1
     )
 
 name, authentication_status, username = authenticator.login('Login', 'main')
@@ -334,7 +335,7 @@ if authentication_status:
     authenticator.logout('Logout', 'sidebar')
     
     # ========================
-    # User Dashboard
+    # User Dashboard with Tabs
     # ========================
     
     st.header("🌟 Dashboard 🌟")
@@ -348,165 +349,260 @@ if authentication_status:
     col1.metric("Tokens", f"{user.balance}")
     col2.metric("Staked Tokens", f"{user.staked}")
     
+    # Create Tabs
+    tabs = st.tabs(["AI Query", "Token Management", "Staking", "Trading", "Transaction History", "Chat", "About Me"])
+    
     # ========================
     # AI Query Submission
     # ========================
+    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:
+                    st.success("✅ AI Query Processed!")
+                    st.write(f"**AI Output:** {ai_output}")
+                    # Mint Token
+                    token_id = str(uuid.uuid4())
+                    token_value = calculate_token_value(ai_output)
+                    token = Token(
+                        id=token_id,
+                        owner_id=user.id,
+                        value=token_value,
+                        verified=False
+                    )
+                    session.add(token)
+                    session.commit()
+                    # Record transaction
+                    transaction = Transaction(
+                        user_id=user.id,
+                        token_id=token.id,
+                        action='submitted_ai_query',
+                        value=token.value
+                    )
+                    session.add(transaction)
+                    session.commit()
+                    st.write(f"**Token ID:** {token_id}")
     
-    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.")
+    # ========================
+    # Token Management
+    # ========================
+    with tabs[1]:
+        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": token.value,
+                    "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:
-            with st.spinner("🔍 Processing your AI query..."):
-                ai_output = process_ai(input_text)
-            if ai_output.startswith("❌"):
-                st.error(ai_output)
+            st.write("📭 You have no tokens yet.")
+    
+    # ========================
+    # Staking
+    # ========================
+    with tabs[2]:
+        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.")
             else:
-                st.success("✅ AI Query Processed!")
-                st.write(f"**AI Output:** {ai_output}")
-                # Mint Token
-                token_id = str(uuid.uuid4())
-                token_value = calculate_token_value(ai_output)
-                token = Token(
-                    id=token_id,
-                    owner_id=user.id,
-                    value=token_value,
-                    verified=False
+                user.balance -= stake_amount
+                user.staked += stake_amount
+                stake = Stake(
+                    user_id=user.id,
+                    amount=stake_amount
                 )
-                session.add(token)
+                session.add(stake)
                 session.commit()
                 # Record transaction
                 transaction = Transaction(
                     user_id=user.id,
-                    token_id=token.id,
-                    action='submitted_ai_query',
-                    value=token.value
+                    action='stake',
+                    value=stake_amount
                 )
                 session.add(transaction)
                 session.commit()
-                st.write(f"**Token ID:** {token_id}")
+                st.success("✅ Staked successfully.")
+                st.write(f"**New Balance:** {user.balance}")
+                st.write(f"**Total Staked:** {user.staked}")
     
     # ========================
-    # Display Tokens
+    # Trading
     # ========================
-    
-    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": token.value,
-                "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("📭 You have no tokens yet.")
-    
-    # ========================
-    # Trade Tokens
-    # ========================
-    
-    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')
-    
-    if trade_button:
-        if seller_username.strip() == "" or token_id.strip() == "":
-            st.error("❌ Seller username and Token ID are required.")
-        else:
-            seller = session.query(User).filter_by(username=seller_username).first()
-            if not seller:
-                st.error("❌ Seller not found.")
+    with tabs[3]:
+        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')
+        
+        if trade_button:
+            if seller_username.strip() == "" or token_id.strip() == "":
+                st.error("❌ Seller username and Token ID are required.")
             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.")
+                seller = session.query(User).filter_by(username=seller_username).first()
+                if not seller:
+                    st.error("❌ Seller not found.")
                 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}")
-                    st.write(f"**Token Value:** {token.value}")
+                    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}")
+                        st.write(f"**Token Value:** {token.value}")
     
     # ========================
-    # Stake Tokens
+    # Transaction History
     # ========================
-    
-    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.")
+    with tabs[4]:
+        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": tx.value,
+                    "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:
-            user.balance -= stake_amount
-            user.staked += stake_amount
-            stake = Stake(
-                user_id=user.id,
-                amount=stake_amount
-            )
-            session.add(stake)
-            session.commit()
-            # Record transaction
-            transaction = Transaction(
-                user_id=user.id,
-                action='stake',
-                value=stake_amount
-            )
-            session.add(transaction)
-            session.commit()
-            st.success("✅ Staked successfully.")
-            st.write(f"**New Balance:** {user.balance}")
-            st.write(f"**Total Staked:** {user.staked}")
+            st.write("📭 No transactions found.")
     
     # ========================
-    # Transaction History
+    # Chat Interface
     # ========================
+    with tabs[5]:
+        st.subheader("💬 Chat with CITIBANK DEMO BUSINESS INC")
+        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}")
     
-    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": tx.value,
-                "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.")
+    # ========================
+    # About Me Tab
+    # ========================
+    with tabs[6]:
+        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.
+        - **Token Minting:** Earn tokens based on the value of AI outputs.
+        - **Token Management:** View and manage your tokens, including verification status.
+        - **Staking:** Stake your tokens to earn rewards and support the network.
+        - **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.
+        - **About Section:** Detailed information about the ecosystem and its functionalities.
+
+        ### 🛠️ Technology Stack
+        - **Backend:** Streamlit, SQLAlchemy, Web3.py
+        - **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
+
+        ### 🔒 Security
+        - **Password Hashing:** User passwords are securely hashed using industry-standard algorithms.
+        - **Blockchain Security:** All interactions with the blockchain are handled securely using Web3.py.
+        - **Input Validation:** Comprehensive validation to prevent vulnerabilities like SQL injection and XSS attacks.
+        - **Secure Data Handling:** Sensitive information such as private keys and 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 for independent scaling and maintenance.
+        - **Efficient Database Management:** Utilizing SQLAlchemy for optimized interactions.
+        - **Asynchronous Processing:** Background threads handle long-running tasks like blockchain verification without blocking the main application.
+
+        ### 📞 Contact
+        **James Burvel O'Callaghan III**  
+        Email: james.ocallaghan@example.com  
+        **CITIBANK DEMO BUSINESS INC**
+
+        ---
+        *Embark on this transformative journey with **CITIBANK DEMO BUSINESS INC** to redefine the synergy between AI and blockchain, creating an unparalleled decentralized economy.*
+        """)
     
     # ========================
     # Background Task for Verification
@@ -527,19 +623,23 @@ if authentication_status:
                     # Interact with blockchain to verify and mint token
                     try:
                         tx_hash = blockchain.verify_output(verification_hash)
-                        minted_token_id = blockchain.mint_token(user.web3.toChecksumAddress(token.owner.username), token.value, verification_hash)  # Replace with actual owner address
+                        # Assuming the user's blockchain address is stored in 'blockchain_address'
+                        owner = session.query(User).filter_by(id=token.owner_id).first()
+                        if not owner.blockchain_address:
+                            st.warning(f"⚠️ User {owner.username} does not have a blockchain address. Skipping token {token.id}.")
+                            continue
+                        minted_token_id = blockchain.mint_token(owner.blockchain_address, token.value, verification_hash)
                         if minted_token_id:
                             # Update token status
                             token.verified = True
                             token.verification_hash = verification_hash
                             session.commit()
                             # Update user's balance
-                            user = session.query(User).get(token.owner_id)
-                            user.balance += token.value
+                            owner.balance += token.value
                             session.commit()
                             # Record transaction
                             transaction = Transaction(
-                                user_id=user.id,
+                                user_id=owner.id,
                                 token_id=token.id,
                                 action='minted',
                                 value=token.value,
@@ -570,20 +670,21 @@ 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:
-        st.sidebar.error("❌ Username and password are required.")
+    if not new_username or not new_password or not blockchain_address:
+        st.sidebar.error("❌ All fields are required.")
+    elif not Web3.is_address(blockchain_address):
+        st.sidebar.error("❌ Invalid Blockchain Address.")
     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)
+        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!")
-
-# ========================
-# End of app.py
-# ========================