Pyth Entropy event with random number not catched on the frontend

DeenankSharma · September 27, 2025, 12:43am

Make sure to check the Pyth Documentation to check for guides, common errors and reference materials.

Myself, Deenank participant of ETHGLOBAL New Delhi . I have made the contract, deployed it on Arbitrium Sepolia (attached below), then on the frontend while testing, payment happens when requesting random Number but then event catcher hook does not receive any randomNumber back. What can be the issue please help.
Contract -
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IEntropyConsumer } from “@pythnetwork/entropy-sdk-solidity/IEntropyConsumer.sol”;

import { IEntropyV2 } from “@pythnetwork/entropy-sdk-solidity/IEntropyV2.sol”;

import { console } from “forge-std/console.sol”;

contract YourContract is IEntropyConsumer {

IEntropyV2 entropy;

mapping(uint64 => bool) public isRequestFulfilled;

mapping(uint64 => bytes32) public receivedRandomNumber;

// Event to notify when a random number is received, without the requestor’s address

event RandomNumberReceived(uint64 indexed sequenceNumber, bytes32 randomNumber);

// @param entropyAddress The address of the entropy contract.

constructor(address entropyAddress) {

entropy = IEntropyV2(entropyAddress);

}

function requestRandomNumber() external payable {

// Get the fee for the request

uint256 fee = entropy.getFeeV2();

require(msg.value >= fee, “Not enough fee to request a random number”);

// Request the random number with the callback

uint64 sequenceNumber = entropy.requestV2{ value: fee }();

console.log("Random number requested with sequence number: %s", sequenceNumber);

// NOTE: We no longer store msg.sender

}

// @param sequenceNumber The sequence number of the request.

// @param provider The address of the provider that generated the random number.

// @param randomNumber The generated random number.

function entropyCallback(

uint64 sequenceNumber,

address provider,

bytes32 randomNumber

) internal override {

console.log("Callback received for sequence number:", sequenceNumber);

console.log("Provider:", provider);

console.log("Random Number:", *uint256*(randomNumber));



isRequestFulfilled\[sequenceNumber\] = true;

receivedRandomNumber\[sequenceNumber\] = randomNumber;

// Emit the event with just the sequence number and the random number

emit RandomNumberReceived(sequenceNumber, randomNumber);

}

// This method is required by the IEntropyConsumer interface.

// It returns the address of the entropy contract which will call the callback.

function getEntropy() internal view override returns (address) {

return address(entropy);

}

JS code
import React, { useState,useEffect } from ‘react’;

import Navbar from ‘../components/Navbar.jsx’;

import ‘../styles/DoctorVerification.css’;

// import { generateZkProof } from ‘../api/zkpdfApi.js’;

import { sendDoctorProof } from ‘../api/sendDoctorProof.js’;

import axios from ‘axios’;

import { useWriteContract, useWaitForTransactionReceipt, useWatchContractEvent } from ‘wagmi’;

const contractABI = [{“type”:“constructor”,“inputs”:[{“name”:“entropyAddress”,“type”:“address”,“internalType”:“address”}],“stateMutability”:“nonpayable”},{“type”:“function”,“name”:“_entropyCallback”,“inputs”:[{“name”:“sequence”,“type”:“uint64”,“internalType”:“uint64”},{“name”:“provider”,“type”:“address”,“internalType”:“address”},{“name”:“randomNumber”,“type”:“bytes32”,“internalType”:“bytes32”}],“outputs”:,“stateMutability”:“nonpayable”},{“type”:“function”,“name”:“isRequestFulfilled”,“inputs”:[{“name”:“”,“type”:“uint64”,“internalType”:“uint64”}],“outputs”:[{“name”:“”,“type”:“bool”,“internalType”:“bool”}],“stateMutability”:“view”},{“type”:“function”,“name”:“receivedRandomNumber”,“inputs”:[{“name”:“”,“type”:“uint64”,“internalType”:“uint64”}],“outputs”:[{“name”:“”,“type”:“bytes32”,“internalType”:“bytes32”}],“stateMutability”:“view”},{“type”:“function”,“name”:“requestRandomNumber”,“inputs”:,“outputs”:,“stateMutability”:“payable”},{“type”:“event”,“name”:“RandomNumberReceived”,“inputs”:[{“name”:“sequenceNumber”,“type”:“uint64”,“indexed”:true,“internalType”:“uint64”},{“name”:“randomNumber”,“type”:“bytes32”,“indexed”:false,“internalType”:“bytes32”}],“anonymous”:false}];

const CONTRACT_ADDRESS = “0xF1c2d6Ef2A8eAd7a124f43901F70534668365160”;

const DoctorVerification = () => {

const [formData, setFormData] = useState({

licenseNumber: ‘’,

specialty: ‘’,

issuingAuthority: ‘’

});

const [dragActive, setDragActive] = useState(false);

// State for Medical License

const [medicalLicenseFile, setMedicalLicenseFile] = useState(null);

const [medicalLicenseFileName, setMedicalLicenseFileName] = useState(“”);

const [medicalLicenseVerified,setMedicalLicenseVerified] = useState(false)

const [isVerifying,setIsVerifying] = useState(true);

const [medicalLicenseConfidence,setMedicalLicenseConfidence] = useState(0)

const [idtext,setidtext] = useState(“Your unique doctor ID will appear here”)

const [randomNumber, setRandomNumber] = useState(‘’);

const [events, setEvents] = useState();

// Hook to write to contract

const { writeContract, data: hash, isPending } = useWriteContract();

// Hook to wait for transaction confirmation

const { isLoading: isConfirming, isSuccess: isConfirmed } = useWaitForTransactionReceipt({

hash,

});

useWatchContractEvent({

address: CONTRACT_ADDRESS,

abi: contractABI,

eventName: ‘RandomNumberReceived’,

onLogs(logs) {

console.log(‘New RandomNumberReceived events:’, logs);

logs.forEach(log => {

const sequenceNumber = log.args.sequenceNumber;

const randomNumberHex = log.args.randomNumber;

// Convert bytes32 to decimal string for display

const randomNumberDecimal = BigInt(randomNumberHex).toString();

const eventData = {

sequenceNumber: sequenceNumber.toString(),

randomNumber: randomNumberHex,

randomNumberDecimal,

blockNumber: log.blockNumber,

transactionHash: log.transactionHash,

timestamp: new Date().toLocaleString()

};

// Store the latest random number

setRandomNumber(randomNumberHex.toString());

// Add to events list

setEvents(prev => [eventData, …prev]);

  });

},

});

// State for ID Document

const [idFile, setIdFile] = useState(null);

const [idFileName, setIdFileName] = useState(“”);

// General State

const [isLoading, setIsLoading] = useState(false);

const [proof, setProof] = useState(null);

const [error, setError] = useState(‘’);

const handleInputChange = (e) => {

setFormData({

…formData,

  \[*e*.target.name\]: *e*.target.value

});

};

const handleFile = async (file, fileType) => {

if (file && file.type === “application/pdf”) {

if (fileType === ‘medicalLicense’) {

setMedicalLicenseFile(file);

setMedicalLicenseFileName(file.name);

try {

// Show loading state (optional)

setIsVerifying(true); // Add this state if you want loading indicator

// Create FormData to send file

const formData = new FormData();

formData.append(‘file’, file);

// Send request to backend

const response = await axios.post(

‘http://localhost:5000/verifyDocCertificate’,

formData,

headers: {

‘Content-Type’: ‘multipart/form-data’,

},

timeout: 30000, // 30 second timeout for verification

      }

    );

// Handle successful response

if (response.data.status === ‘success’) {

if (response.data.verified) {

setMedicalLicenseVerified(true);

setMedicalLicenseConfidence(response.data.confidence);

setError(‘’); // Clear any previous errors

      } else {

setMedicalLicenseVerified(false);

setError(‘Medical license could not be verified. Please check the document and try again.’);

      }

    } else {

setError(‘Verification failed. Please try again.’);

    }

  } catch (error) {

console.error(‘Error verifying medical license:’, error);

// Handle different types of errors

if (error.code === ‘ECONNABORTED’) {

setError(‘Verification timeout. Please try again.’);

    } else if (error.response) {

// Server responded with error status

const errorMessage = error.response.data?.error || ‘Server error during verification’;

setError(errorMessage);

    } else if (error.request) {

// Request was made but no response received

setError(‘Unable to connect to verification service. Please check your connection.’);

    } else {

// Something else happened

setError(‘An unexpected error occurred during verification.’);

// Reset verification state on error

setMedicalLicenseVerified(false);

setMedicalLicenseConfidence(0);

  } finally {

setIsVerifying(false); // Hide loading state

  }

} else if (*fileType* === 'id') {

setIdFile(file);

setIdFileName(file.name);

// You can add similar verification logic for ID documents here if needed

// For now, just setting the file without verification

setError(‘’); // Clear previous errors on new valid upload

setProof(null); // Clear previous proofs

} else {

setError(“Please upload a valid PDF file.”);

// Clear file states if invalid file

if (fileType === ‘medicalLicense’) {

setMedicalLicenseFile(null);

setMedicalLicenseFileName(‘’);

setMedicalLicenseVerified(false);

setMedicalLicenseConfidence(0);

} else if (*fileType* === 'id') {

setIdFile(null);

setIdFileName(‘’);

}

};

const handleGenerateProof = async () => {

if (!medicalLicenseFile || !idFile) {

setError(‘Please upload both a medical license and an ID document.’);

return;

setIsLoading(true);

setError(‘’);

setProof(null);

// Commented out actual ZK proof generation, using mock data for now

/*

try {

    // Generate proofs for both files concurrently

    const \[medicalLicenseProofData, idProofData\] = await Promise.all(\[

      generateZkProof(medicalLicenseFile),

      generateZkProof(idFile)

    \]);

    setProof({

      medicalLicense: JSON.stringify(medicalLicenseProofData, null, 2),

      id: JSON.stringify(idProofData, null, 2)

    });



  } catch (err) {

    setError(err.message || 'An error occurred while generating proofs.');

  } finally {

    setIsLoading(false);

  }

\*/

// Use mock data for proof

setProof({

medicalLicense: JSON.stringify({ proof: “mock_medical_license_proof”, details: “This is mock data.” }, null, 2),

id: JSON.stringify({ proof: “mock_id_proof”, details: “This is mock data.” }, null, 2)

});

setIsLoading(false);

};

useEffect(() => {

if (proof) {

sendDoctorProof(JSON.parse(proof))

      .then((*res*) => {

console.log(‘Proof sent to backend:’, res);

      })

      .catch((*err*) => {

console.error(‘Error sending proof to backend:’, err);

      });

  }

}, \[proof\]);

const handleDrag = (e) => {

e.preventDefault();

e.stopPropagation();

if (e.type === ‘dragenter’ || e.type === ‘dragover’) {

setDragActive(true);

} else if (*e*.type === 'dragleave') {

setDragActive(false);

};

const handleDrop = (e, fileType) => {

e.preventDefault();

e.stopPropagation();

setDragActive(false);

if (e.dataTransfer.files && e.dataTransfer.files[0]) {

console.log(e.dataTransfer.files);

handleFile(e.dataTransfer.files[0], fileType);

};

const handleFileUpload = (e, fileType) => {

if (e.target.files && e.target.files[0]) {

console.log(e.target.files[0]);

handleFile(e.target.files[0], fileType);

};

const handleCancel = () => {

setFormData({

// licenseNumber: ‘’,

name:‘’,

specialty: ‘’,

// issuingAuthority: ‘’

});

setMedicalLicenseFile(null);

setMedicalLicenseFileName(“”);

setIdFile(null);

setIdFileName(“”);

setProof(null);

setError(“”);

setIsLoading(false);

};

const handleSubmit = async () => {

if (!proof) {

setError(‘Please generate the proofs before submitting.’);

return;

if (!medicalLicenseFile) {

setError(‘Please upload your medical license PDF.’);

return;

// Prepare FormData with all details and the certificate file

const formDataToSend = new FormData();

formDataToSend.append(‘name’, formData.licenseNumber);

formDataToSend.append(‘specialty’, formData.specialty);

formDataToSend.append(‘nationality’, ‘IND’);

formDataToSend.append(‘certificate’, medicalLicenseFile);

// Add doctor address here (replace with actual address from wallet integration)

formDataToSend.append(‘doctorAddress’, window.ethereum?.selectedAddress || “0xDoctorAddress”);

try {

const response = await axios.post(‘http://localhost:5000/api/doctors/register’, formDataToSend, {

headers: { ‘Content-Type’: ‘multipart/form-data’ }

});

// Handle response as needed

console.log(‘Doctor registered:’, response.data);

} catch (err) {

setError('Registration failed: ’ + (err.message || ‘Unknown error’));

}

async function generateRandomId() {

try {

console.log(‘Requesting random number from contract…’);

setIsLoading(true);

await writeContract({

address: CONTRACT_ADDRESS,

abi: contractABI,

functionName: ‘requestRandomNumber’,

value: BigInt(‘1000000000000000’), // 0.001 ETH in wei - adjust based on actual fee

});

console.log(‘Random number request sent.’);

} catch (err) {

console.error(‘Transaction failed:’, err);

} finally {

setIsLoading(false);

}

// Update loading state based on transaction status

useEffect(() => {

setIsLoading(isPending || isConfirming);

}, [isPending, isConfirming]);

return (

<Navbar />

Doctor Credential Verification

        Securely submit your credentials for verification on the blockchain. Help us build a trusted and transparent healthcare ecosystem.

Medical License Information

{/*

This Information will be encrypted and stored securely

*/}

<label className=“form-label”>Name

<label className=“form-label”>Speciality

{/*

          <label className="form-label">Issuing Authority</label>

          <input type="text" name="issuingAuthority" className="form-input" placeholder="eg. State Medical Board" value={formData.issuingAuthority} onChange={handleInputChange} />

        </div> \*/}

Upload and Verify Documents

1. Please upload a clear copy of your Medical License (PDF only).

handleDrop(*e*, 'medicalLicense')}>

{medicalLicenseFileName ? medicalLicenseFileName : <><span className=“upload-bold”>Upload a PDF file or drag and drop</>}

<input type=“file” className=“file-input” accept=“.pdf” onChange={(e) => handleFileUpload(e, ‘medicalLicense’)} />

2. Please upload a clear copy of your ID Document (PDF: Aadhar, PAN, etc.).

handleDrop(*e*, 'id')}>

{idFileName ? idFileName : <><span className=“upload-bold”>Upload a PDF file or drag and drop</>}

<input type=“file” className=“file-input” accept=“.pdf” onChange={(e) => handleFileUpload(e, ‘id’)} />

{error && <p className=“error-message”>{error}

}

{isLoading && <p className=“loading-message”>Generating your secure proofs… This may take a moment.

}

{proof && (

Proofs Generated Successfully!

Medical License Proof

{proof.medicalLicense}

ID Document Proof

{proof.id}

)}

<button className=“cancel-btn” onClick={handleCancel}>Cancel

{isLoading ? ‘Generating Proofs…’ : ‘Generate ZK Proof’}

Generate your ID

Your ID, Your Identity

{/* */}

<input

type=“text”

style={{width: ‘100%’,marginBottom: ‘20px’}}

className=“form-input”

value={randomNumber || ‘’}

readOnly

placeholder={idtext}

/>

<button

className=“submit-btn”

onClick={async () => {

setidtext(“Generating your unique doctor ID…”);

generateRandomId();

}}

disabled={isLoading}

>

          Generate Doctor ID

<button className=‘submit-btn’ onClick={handleSubmit} style={{alignSelf:‘center’}} disabled = {isLoading || !medicalLicenseFile || !idFile || !proof || !medicalLicenseVerified} >Register

);

};

export default DoctorVerification;

Aditya520 · September 27, 2025, 5:00am

Have you checked your tx hash on the entropy explorer?

Topic		Replies	Views
Understanding Entropy after a long hack Entropy	1	470	June 1, 2025
No entropyCallback on Sanko Testchain - sequenceNumber 433 Entropy	1	447	May 31, 2025
Generating user Random Number Entropy	1	450	April 6, 2025
Entropy Callback function integration on Story Entropy	1	248	October 29, 2025
Small note reg my submission Whiphash to Pyth Team! Entropy announcements , entropy , evm	1	255	October 28, 2025

Pyth Entropy event with random number not catched on the frontend

Doctor Credential Verification

Medical License Information

Upload and Verify Documents

Proofs Generated Successfully!

Medical License Proof

ID Document Proof

Generate your ID

Related topics