Update src/trust_agent.py

src/trust_agent.py

@@ -161,72 +161,101 @@ class AgentTrust:
         except: return "IPFS_Fail"
 
     # --- CORE BLOCKCHAIN LOGIC ---
-    def stamp_on_chain(self, payload, **kwargs):
-        """Mints a verified dialect entry to PureChain."""
-        print(f"⛓️ Attempting to mint to PureChain: {payload.get('original')}")
+    def stamp_on_chain(self, payload):
+        """
+        Hashes the validated sociolinguistic data and mints it to the Purechain ledger
+        using the PureConvo contract's proposeEntry function.
+        """
+        import json
+        import hashlib
+        import os
+        from web3 import Web3
+        from web3.middleware import geth_poa_middleware
+        
+        print("\n" + "="*40)
+        print("⛓️ INITIATING PURECHAIN MINTING SEQUENCE")
         
         try:
-            if not hasattr(self, 'w3') or not self.w3.is_connected():
-                print("❌ PureChain not connected. Cannot mint.")
+            # 1. Load Environment Variables (Updated to match your secrets)
+            rpc_url = os.environ.get("PURECHAIN_RPC_URL")
+            private_key = os.environ.get("PRIVATE_KEY")
+            contract_address = os.environ.get("PURECHAIN_CONTRACT_ADDRESS")
+            
+            if not all([rpc_url, private_key, contract_address]):
+                print("⚠️ Purechain skipped: Missing RPC_URL, PRIVATE_KEY, or PURECHAIN_CONTRACT_ADDRESS.")
                 return False
 
-            # 🟢 Use the global CONTRACT_ABI, not self.config.CONTRACT_ABI
-            contract = self.w3.eth.contract(
-                address=self.config.PURECHAIN_CONTRACT_ADDRESS, 
-                abi=CONTRACT_ABI
-            )
-            
-            # 2. Extract Data from Payload
-            phrase = payload.get("original", "Unknown Phrase")
-            dialect = payload.get("dialect", "General")
-            
-            # If you aren't using Pinata/IPFS yet, use a placeholder
-            ipfs_cid = payload.get("ipfs_cid", "pending_ipfs_hash") 
-            license_type = "Open Research"
+            # 2. Establish Network Connection
+            w3 = Web3(Web3.HTTPProvider(rpc_url))
+            w3.middleware_onion.inject(geth_poa_middleware, layer=0) # PoA compatibility
+
+            if not w3.is_connected():
+                print("🔴 Purechain connection failed. Network may be offline.")
+                return False
+
+            account = w3.eth.account.from_key(private_key)
+            wallet_address = account.address
+            print(f"✅ Authenticated as Operator: {wallet_address}")
+
+            # 3. Cryptographic Hashing of the Data
+            # We hash the full JSON payload to use as our "IPFS CID" / Data Hash proof
+            payload_str = json.dumps(payload, sort_keys=True)
+            data_hash = hashlib.sha256(payload_str.encode('utf-8')).hexdigest()
+            print(f"🔒 Payload SHA-256 Proof: {data_hash}")
+
+            # 4. Load the Smart Contract using your config.py ABI
+            # Ensure your config is imported/available in trust_agent.py
+            contract = w3.eth.contract(address=contract_address, abi=self.config.CONTRACT_ABI)
+
+            # 5. Extract values for the proposeEntry parameters
+            # function proposeEntry(string _phrase, string _dialect, string _ipfsCid, string _license)
+            phrase = payload.get("original", "Unknown Utterance")
+            dialect = payload.get("dialect", "Unknown Dialect")
+            license_type = "CC-BY-4.0 (Open Research)" # Academic open data license
 
-            # 3. Prepare the Wallet Account
-            account = self.w3.eth.account.from_key(self.config.PRIVATE_KEY)
-            nonce = self.w3.eth.get_transaction_count(account.address)
+            # 6. Build the Transaction
+            nonce = w3.eth.get_transaction_count(wallet_address)
             
-            # 4. Build the Transaction targeting 'proposeEntry'
             tx = contract.functions.proposeEntry(
                 phrase, 
                 dialect, 
-                ipfs_cid, 
+                data_hash, 
                 license_type
             ).build_transaction({
-                'from': account.address,
+                'chainId': w3.eth.chain_id,
+                'gas': 2000000, 
+                'gasPrice': w3.eth.gas_price,
                 'nonce': nonce,
-                'gas': 3000000, # Increased gas limit to prevent Out-Of-Gas reverts
-                'gasPrice': 0,
-                'chainId': self.config.PURECHAIN_ID
             })
+
+            # 7. Sign and Broadcast
+            signed_tx = w3.eth.account.sign_transaction(tx, private_key)
+            tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
+            hex_hash = w3.to_hex(tx_hash)
             
-            # 5. Sign and Send
-            print("✍️ Signing transaction...")
-            signed_tx = self.w3.eth.account.sign_transaction(tx, private_key=self.config.PRIVATE_KEY)
-            tx_hash = self.w3.eth.send_raw_transaction(signed_tx.rawTransaction)
-            
-            # 6. Wait for Confirmation
-            print(f"⏳ Waiting for confirmation on TX: {tx_hash.hex()}...")
-            receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
+            print(f"🚀 Transaction Broadcasted! TX Hash: {hex_hash}")
+
+            # 8. Wait for Confirmation
+            receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=120)
             
-            # 7. Check if it Succeeded or Reverted
             if receipt.status == 1:
-                print(f"✅ SUCCESS! Minted to PureChain in Block: {receipt.blockNumber}")
-                
-                # 🟢 FIX: Trigger the local history logger and HF sync!
-                self.log_mint_to_history(phrase, dialect, tx_hash.hex(), receipt.blockNumber, ipfs_cid)
+                print(f"💎 SUCCESS: Entry '{phrase[:15]}...' irreversibly minted in Block {receipt.blockNumber}")
                 
+                # OPTIONAL: Save the receipt to your Gradio Transaction History tab
+                if hasattr(self, '_log_transaction_history'):
+                    self._log_transaction_history(payload, hex_hash, receipt.blockNumber)
                 return True
             else:
-                print(f"❌ REVERTED! The smart contract rejected the transaction.")
-                print("Make sure your wallet address is registered via 'registerResearcher' first!")
+                print("⚠️ Transaction reverted by the EVM. (Check if wallet is registered)")
                 return False
-                
+
         except Exception as e:
-            print(f"🚨 Blockchain Error during minting: {e}")
+            import traceback
+            print(f"\n❌ SMART CONTRACT ERROR ❌\n{e}")
+            traceback.print_exc()
             return False
+        finally:
+            print("="*40 + "\n")
 
     def log_mint_to_history(self, utterance, dialect, tx_hash, block_num, cid):
         history_file = "/app/minted_history.csv"