ReputationSingleton Contract¶

import { ethers } from 'ethers';

class QuickEvaluator {
    constructor(contractAddress, signer) {
        this.contract = new ethers.Contract(
            contractAddress,
            REPUTATION_SINGLETON_ABI,
            signer
        );
        this.linkToken = new ethers.Contract(
            LINK_TOKEN_ADDRESS,
            LINK_ABI,
            signer
        );
    }

    async submitQuickEvaluation(evidenceFiles, description, options = {}) {
        try {
            // Upload evidence to IPFS
            const cids = await Promise.all(
                evidenceFiles.map(file => this.uploadToIPFS(file))
            );

            // Configure request parameters
            const params = {
                alpha: options.prioritizeSpeed ? 800 : 500,
                maxFee: options.maxFee || ethers.parseEther("0.05"),
                baseCost: options.baseCost || ethers.parseEther("0.005"),
                scalingFactor: options.scalingFactor || 3,
                oracleClass: options.oracleClass || 1
            };

            // Calculate total cost (base + bonus)
            const totalCost = await this.contract.maxTotalFee(params.maxFee);

            // Approve LINK tokens
            await this.linkToken.approve(this.contract.target, totalCost);

            // Submit request
            const tx = await this.contract.requestAIEvaluationWithApproval(
                cids,
                description,
                params.alpha,
                params.maxFee,
                params.baseCost,
                params.scalingFactor,
                params.oracleClass
            );

            console.log("Quick evaluation submitted:", tx.hash);
            const receipt = await tx.wait();

            // Extract request ID from events
            const event = receipt.logs.find(
                log => log.topics[0] === this.contract.interface.getEvent("RequestAIEvaluation").topicHash
            );
            const requestId = event.topics[1];

            return {
                requestId,
                transactionHash: tx.hash,
                estimatedCompletionTime: Date.now() + 60000, // ~1 minute
                cost: ethers.formatEther(totalCost)
            };

        } catch (error) {
            console.error("Failed to submit evaluation:", error);
            throw error;
        }
    }

    async pollForResult(requestId, maxWaitTime = 300000) { // 5 minutes max
        const startTime = Date.now();

        while (Date.now() - startTime < maxWaitTime) {
            const [likelihoods, justificationCID, exists] = 
                await this.contract.getEvaluation(requestId);

            if (exists) {
                return {
                    status: 'complete',
                    likelihoods: likelihoods.map(l => Number(l)),
                    justificationCID,
                    justification: await this.fetchFromIPFS(justificationCID),
                    completionTime: Date.now() - startTime
                };
            }

            // Check if failed
            const failed = await this.contract.isFailed(requestId);
            if (failed) {
                return {
                    status: 'failed',
                    error: 'Evaluation timed out or failed'
                };
            }

            // Wait before next check
            await new Promise(resolve => setTimeout(resolve, 5000));
        }

        return {
            status: 'timeout',
            error: 'Maximum wait time exceeded'
        };
    }

    watchEvaluation(requestId) {
        return new Promise((resolve, reject) => {
            const timeout = setTimeout(() => {
                cleanup();
                reject(new Error('Evaluation timeout'));
            }, 300000); // 5 minute timeout

            const fulfillFilter = this.contract.filters.EvaluationFulfilled(requestId);
            const failFilter = this.contract.filters.EvaluationFailed(requestId);

            const cleanup = () => {
                this.contract.off(fulfillFilter);
                this.contract.off(failFilter);
                clearTimeout(timeout);
            };

            this.contract.once(fulfillFilter, async (reqId, likelihoods, justificationCID) => {
                cleanup();
                resolve({
                    status: 'complete',
                    likelihoods: likelihoods.map(l => Number(l)),
                    justificationCID,
                    justification: await this.fetchFromIPFS(justificationCID)
                });
            });

            this.contract.once(failFilter, (reqId) => {
                cleanup();
                reject(new Error('Evaluation failed'));
            });
        });
    }
}

import { useState, useCallback, useEffect } from 'react';
import { useContract, useSigner } from './web3-hooks';

export function useQuickEvaluation(contractAddress) {
    const signer = useSigner();
    const contract = useContract(contractAddress, REPUTATION_SINGLETON_ABI, signer);
    const [evaluations, setEvaluations] = useState({});

    const submitEvaluation = useCallback(async (files, description, options) => {
        if (!contract) throw new Error('Contract not available');

        const evaluator = new QuickEvaluator(contractAddress, signer);
        const result = await evaluator.submitQuickEvaluation(files, description, options);

        setEvaluations(prev => ({
            ...prev,
            [result.requestId]: {
                ...result,
                status: 'pending'
            }
        }));

        // Watch for completion
        evaluator.watchEvaluation(result.requestId)
            .then(completedResult => {
                setEvaluations(prev => ({
                    ...prev,
                    [result.requestId]: {
                        ...prev[result.requestId],
                        ...completedResult
                    }
                }));
            })
            .catch(error => {
                setEvaluations(prev => ({
                    ...prev,
                    [result.requestId]: {
                        ...prev[result.requestId],
                        status: 'failed',
                        error: error.message
                    }
                }));
            });

        return result.requestId;
    }, [contract, contractAddress, signer]);

    const getEvaluation = useCallback((requestId) => {
        return evaluations[requestId];
    }, [evaluations]);

    return {
        submitEvaluation,
        getEvaluation,
        evaluations
    };
}

// Development/Testing
const devConfig = {
    alpha: 500,           // Balanced
    maxFee: ethers.parseEther("0.01"),
    baseCost: ethers.parseEther("0.001"),
    scalingFactor: 2
};

// Production - Speed Priority
const speedConfig = {
    alpha: 800,           // Favor timeliness
    maxFee: ethers.parseEther("0.05"),
    baseCost: ethers.parseEther("0.005"),
    scalingFactor: 5
};

// Production - Cost Priority
const costConfig = {
    alpha: 300,           // Favor quality over speed
    maxFee: ethers.parseEther("0.02"),
    baseCost: ethers.parseEther("0.002"),
    scalingFactor: 2
};

// Set appropriate timeout and handle failures
const timeout = await contract.responseTimeoutSeconds();
setTimeout(async () => {
    const failed = await contract.isFailed(requestId);
    if (!failed) {
        await contract.finalizeEvaluationTimeout(requestId);
    }
}, timeout * 1000);