Update app.py

app.py

@@ -13,6 +13,7 @@ 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
@@ -21,7 +22,6 @@ from sqlalchemy.orm import sessionmaker, relationship
 from werkzeug.security import generate_password_hash, check_password_hash
 
 import openai
-from web3 import Web3, exceptions
 
 # ========================
 # Streamlit Configuration UI
@@ -178,78 +178,56 @@ class Blockchain:
     
     def load_contract_abi(self):
         """
-        Load the contract ABI from a JSON file.
-        Replace this method's implementation with the actual ABI loading mechanism.
+        Load the contract ABI from 'contract_abi.json'.
         """
-        # For demonstration, we'll define a sample ABI. Replace with your actual contract's ABI.
-        sample_abi = [
-            {
-                "anonymous": False,
-                "inputs": [
-                    {"indexed": False, "internalType": "uint256", "name": "tokenId", "type": "uint256"},
-                    {"indexed": False, "internalType": "address", "name": "owner", "type": "address"},
-                    {"indexed": False, "internalType": "uint256", "name": "value", "type": "uint256"},
-                    {"indexed": False, "internalType": "string", "name": "hash", "type": "string"}
-                ],
-                "name": "TokenMinted",
-                "type": "event"
-            },
-            {
-                "inputs": [
-                    {"internalType": "uint256", "name": "_grade", "type": "uint256"},
-                    {"internalType": "string", "name": "_hash", "type": "string"}
-                ],
-                "name": "mintToken",
-                "outputs": [
-                    {"internalType": "uint256", "name": "", "type": "uint256"}
-                ],
-                "stateMutability": "payable",
-                "type": "function"
-            },
-            {
-                "inputs": [
-                    {"internalType": "uint256", "name": "_tokenId", "type": "uint256"},
-                    {"internalType": "string", "name": "_hash", "type": "string"}
-                ],
-                "name": "verifyToken",
-                "outputs": [],
-                "stateMutability": "nonpayable",
-                "type": "function"
-            }
-        ]
-        return sample_abi
+        try:
+            with open('contract_abi.json') as f:
+                contract_abi = json.load(f)
+            return contract_abi
+        except FileNotFoundError:
+            st.error("❌ 'contract_abi.json' file not found. Please ensure the ABI file is present.")
+            raise
+        except json.JSONDecodeError:
+            st.error("❌ Error decoding 'contract_abi.json'. Please ensure it is valid JSON.")
+            raise
     
-    def mint_token(self, owner_address, grade, verification_hash):
+    def mint_token_via_api(self, address, token, balance):
         """
-        Mints a new token on the blockchain based on AI grading.
-        Returns the token ID.
+        Mints tokens by calling the external API endpoint.
+        Returns the response status and data.
         """
-        nonce = self.web3.eth.get_transaction_count(self.account.address)
-        tx = self.contract.functions.mintToken(
-            grade,
-            verification_hash
-        ).buildTransaction({
-            'from': self.account.address,
-            'value': self.web3.toWei('0.01', 'ether'),  # Mint fee
-            'gas': 300000,
-            'gasPrice': self.web3.toWei('20', 'gwei'),
-            'nonce': nonce,
-        })
-        signed_tx = self.web3.eth.account.sign_transaction(tx, self.private_key)
+        url = 'https://backend.buildbear.io/node/faucet/erc20/linguistic-doctorstrange-fb0930a4'
+        headers = {
+            'accept': '*/*',
+            'accept-language': 'en-US,en;q=0.9',
+            'cache-control': 'no-cache',
+            'content-type': 'application/json',
+            'dnt': '1',
+            'origin': 'https://faucet.buildbear.io',
+            'pragma': 'no-cache',
+            'priority': 'u=1, i',
+            'referer': 'https://faucet.buildbear.io/',
+            'sec-ch-ua': '"Not(A:Brand";v="99", "Google Chrome";v="133", "Chromium";v="133"',
+            'sec-ch-ua-mobile': '?0',
+            'sec-ch-ua-platform': '"Chrome OS"',
+            'sec-fetch-dest': 'empty',
+            'sec-fetch-mode': 'cors',
+            'sec-fetch-site': 'same-site',
+            'user-agent': 'Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36'
+        }
+        payload = {
+            "address": address,
+            "token": token,
+            "balance": balance
+        }
         try:
-            tx_hash = self.web3.eth.send_raw_transaction(signed_tx.rawTransaction)
-            receipt = self.web3.eth.wait_for_transaction_receipt(tx_hash)
-            # Extract token ID from event logs
-            events = self.contract.events.TokenMinted().processReceipt(receipt)
-            if events:
-                token_id = events[0]['args']['tokenId']
-                return token_id
+            response = requests.post(url, headers=headers, json=payload)
+            if response.status_code == 200:
+                return True, response.json()
             else:
-                st.error("❌ TokenMinted event not found.")
-                return None
+                return False, response.text
         except Exception as e:
-            st.error(f"❌ Blockchain transaction failed: {str(e)}")
-            return None
+            return False, str(e)
     
     def verify_output(self, token_id, verification_hash):
         """
@@ -404,17 +382,21 @@ if authentication_status:
                     # 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:
+                        # Mint Token via API
+                        token_address = user.blockchain_address
+                        token_contract = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"  # Example token address (USDC)
+                        balance = str(int(token_amount))
+                        mint_success, mint_response = blockchain.mint_token_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,
                                 verified=False,
-                                verification_hash=verification_hash
+                                verification_hash=hashlib.sha256(ai_output.encode()).hexdigest()
                             )
                             session.add(token)
                             session.commit()
@@ -427,12 +409,14 @@ if authentication_status:
                                 token_id=token.id,
                                 action='minted',
                                 value=token_amount,
-                                hash=verification_hash
+                                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}")
                     else:
                         st.error("❌ Token amount determined as zero. Please try again.")