Update app.py

app.py

@@ -21,7 +21,7 @@ from sqlalchemy.orm import sessionmaker, relationship
 from werkzeug.security import generate_password_hash, check_password_hash
 
 import openai
-from web3 import Web3
+from web3 import Web3, exceptions
 
 # ========================
 # Streamlit Configuration UI
@@ -112,7 +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
+    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)
 
@@ -196,43 +196,41 @@ class Blockchain:
             },
             {
                 "inputs": [
-                    {"internalType": "address", "name": "owner", "type": "address"},
-                    {"internalType": "uint256", "name": "value", "type": "uint256"},
-                    {"internalType": "string", "name": "hash", "type": "string"}
+                    {"internalType": "uint256", "name": "_grade", "type": "uint256"},
+                    {"internalType": "string", "name": "_hash", "type": "string"}
                 ],
                 "name": "mintToken",
                 "outputs": [
                     {"internalType": "uint256", "name": "", "type": "uint256"}
                 ],
-                "stateMutability": "nonpayable",
+                "stateMutability": "payable",
                 "type": "function"
             },
             {
                 "inputs": [
-                    {"internalType": "string", "name": "data", "type": "string"}
-                ],
-                "name": "verifyData",
-                "outputs": [
-                    {"internalType": "bool", "name": "", "type": "bool"}
+                    {"internalType": "uint256", "name": "_tokenId", "type": "uint256"},
+                    {"internalType": "string", "name": "_hash", "type": "string"}
                 ],
+                "name": "verifyToken",
+                "outputs": [],
                 "stateMutability": "nonpayable",
                 "type": "function"
             }
         ]
         return sample_abi
     
-    def mint_token(self, owner_address, value, verification_hash):
+    def mint_token(self, owner_address, grade, verification_hash):
         """
-        Mints a new token on the blockchain.
+        Mints a new token on the blockchain based on AI grading.
         Returns the token ID.
         """
         nonce = self.web3.eth.get_transaction_count(self.account.address)
         tx = self.contract.functions.mintToken(
-            owner_address,
-            int(value),
+            grade,
             verification_hash
         ).buildTransaction({
-            'chainId': self.web3.eth.chain_id,
+            'from': self.account.address,
+            'value': self.web3.toWei('0.01', 'ether'),  # Mint fee
             'gas': 300000,
             'gasPrice': self.web3.toWei('20', 'gwei'),
             'nonce': nonce,
@@ -253,14 +251,16 @@ class Blockchain:
             st.error(f"❌ Blockchain transaction failed: {str(e)}")
             return None
     
-    def verify_output(self, data):
+    def verify_output(self, token_id, verification_hash):
         """
         Verifies the AI output on the blockchain.
-        Returns the transaction hash.
         """
         nonce = self.web3.eth.get_transaction_count(self.account.address)
-        tx = self.contract.functions.verifyData(data).buildTransaction({
-            'chainId': self.web3.eth.chain_id,
+        tx = self.contract.functions.verifyToken(
+            token_id,
+            verification_hash
+        ).buildTransaction({
+            'from': self.account.address,
             'gas': 70000,
             'gasPrice': self.web3.toWei('20', 'gwei'),
             'nonce': nonce,
@@ -281,12 +281,41 @@ blockchain = Blockchain()
 # Utility Functions
 # ========================
 
-def calculate_token_value(ai_output):
+def calculate_token_grade(ai_output):
     """
-    Calculate token value based on AI output.
-    For demonstration, we use the length of the output.
+    Sends AI output back to AI to grade it based on a predefined rubric.
+    Returns the grade which determines the number of tokens.
     """
-    return float(len(ai_output))
+    try:
+        # Define the grading rubric as a prompt
+        grading_prompt = f"""
+        Please grade the following AI-generated content based on its relevance, coherence, and usefulness. 
+        Use a scale from 1 to 10, where 10 is highly valuable and 1 is not valuable at all.
+
+        AI Output:
+        \"\"\"
+        {ai_output}
+        \"\"\"
+
+        Grade:
+        """
+        response = openai.Completion.create(
+            engine="text-davinci-003",  # Use 'gpt-4' if available
+            prompt=grading_prompt,
+            max_tokens=10,
+            temperature=0,
+            n=1,
+            stop=None
+        )
+        grade_text = response.choices[0].text.strip()
+        grade = int(grade_text)
+        # Define maximum tokens per grade
+        max_tokens = 100
+        token_amount = (grade / 10) * max_tokens
+        return token_amount
+    except Exception as e:
+        st.error(f"❌ Error grading AI output: {str(e)}")
+        return 0
 
 def process_ai(input_text):
     """
@@ -346,8 +375,8 @@ if authentication_status:
     # Display Balance
     st.subheader("💰 Your Balance")
     col1, col2 = st.columns(2)
-    col1.metric("Tokens", f"{user.balance}")
-    col2.metric("Staked Tokens", f"{user.staked}")
+    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"])
@@ -372,27 +401,40 @@ if authentication_status:
                 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}")
+                    # Grade AI Output
+                    token_amount = calculate_token_grade(ai_output)
+                    if token_amount > 0:
+                        # Mint Token
+                        verification_hash = hashlib.sha256(ai_output.encode()).hexdigest()
+                        token_id = blockchain.mint_token(user.blockchain_address, token_amount, verification_hash)
+                        if token_id:
+                            # Update local database
+                            token = Token(
+                                id=str(uuid.uuid4()),
+                                owner_id=user.id,
+                                value=token_amount,
+                                verified=False,
+                                verification_hash=verification_hash
+                            )
+                            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=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("❌ Token amount determined as zero. Please try again.")
     
     # ========================
     # Token Management
@@ -405,7 +447,7 @@ if authentication_status:
             for token in tokens:
                 token_info = {
                     "Token ID": token.id,
-                    "Value": token.value,
+                    "Value": f"{token.value:.2f}",
                     "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')
@@ -447,8 +489,8 @@ if authentication_status:
                 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(f"**New Balance:** {user.balance:.2f}")
+                st.write(f"**Total Staked:** {user.staked:.2f}")
     
     # ========================
     # Trading
@@ -489,8 +531,8 @@ if authentication_status:
                         session.add(transaction)
                         session.commit()
                         st.success("✅ Trade successful.")
-                        st.write(f"**New Balance:** {user.balance}")
-                        st.write(f"**Token Value:** {token.value}")
+                        st.write(f"**New Balance:** {user.balance:.2f}")
+                        st.write(f"**Token Value:** {token.value:.2f}")
     
     # ========================
     # Transaction History
@@ -503,7 +545,7 @@ if authentication_status:
             for tx in transactions:
                 tx_info = {
                     "Action": tx.action,
-                    "Value": tx.value,
+                    "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')
                 }
@@ -516,7 +558,7 @@ if authentication_status:
     # Chat Interface
     # ========================
     with tabs[5]:
-        st.subheader("💬 Chat with CITIBANK DEMO BUSINESS INC")
+        st.subheader("💬 Chat with CITIBANK DEMO BUSINESS INC AI")
         if 'chat_history' not in st.session_state:
             st.session_state['chat_history'] = []
         
@@ -546,13 +588,13 @@ if authentication_status:
             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))
+                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 DEMO BUSINESS INC AI:** {message}")
+                st.markdown(f"**CITIBANK AI:** {message}")
     
     # ========================
     # About Me Tab
@@ -566,9 +608,10 @@ 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.
-        - **Token Minting:** Earn tokens based on the value of AI outputs.
+        - **AI Grading Mechanism:** AI evaluates its own outputs based on a predefined rubric to determine token rewards.
+        - **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 network.
+        - **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.
@@ -591,15 +634,15 @@ if authentication_status:
         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.
+        - **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 like blockchain verification without blocking the main application.
-
+        - **Optimized Blockchain Interactions:** Efficient gas usage and transaction management to handle high volumes of token minting and verification.
 
         ---
         *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
     # ========================
@@ -609,7 +652,7 @@ if authentication_status:
         Background thread to verify unverified tokens.
         """
         while True:
-            time.sleep(10)  # Simulate delay
+            time.sleep(30)  # Check every 30 seconds
             with session:
                 unverified_tokens = session.query(Token).filter_by(verified=False).all()
                 for token in unverified_tokens:
@@ -618,26 +661,17 @@ if authentication_status:
                     verification_hash = hashlib.sha256(data.encode()).hexdigest()
                     # Interact with blockchain to verify and mint token
                     try:
-                        tx_hash = blockchain.verify_output(verification_hash)
-                        # 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:
+                        tx_hash = blockchain.verify_output(token.id, verification_hash)
+                        if tx_hash:
                             # Update token status
                             token.verified = True
                             token.verification_hash = verification_hash
                             session.commit()
-                            # Update user's balance
-                            owner.balance += token.value
-                            session.commit()
                             # Record transaction
                             transaction = Transaction(
-                                user_id=owner.id,
+                                user_id=token.owner_id,
                                 token_id=token.id,
-                                action='minted',
+                                action='verified',
                                 value=token.value,
                                 hash=verification_hash
                             )