SimpleContract¶

import { ethers } from 'ethers';

class SimpleEvaluator {
    constructor(contractAddress, signer) {
        this.contract = new ethers.Contract(
            contractAddress,
            SIMPLE_CONTRACT_ABI,
            signer
        );
    }

    async getConfiguration() {
        const [oracle, linkAddr, jobId, fee] = 
            await this.contract.getContractConfig();
        const maxTotalFee = await this.contract.maxTotalFee(0);
        const timeout = await this.contract.responseTimeoutSeconds();

        return {
            oracle,
            linkToken: linkAddr,
            jobId,
            fee: ethers.formatEther(fee),
            maxTotalFee: ethers.formatEther(maxTotalFee),
            timeoutSeconds: Number(timeout)
        };
    }

    async submitEvaluation(contentHash, description = "") {
        try {
            const config = await this.getConfiguration();

            // Approve LINK tokens
            const linkToken = new ethers.Contract(
                config.linkToken,
                LINK_ABI,
                this.contract.signer
            );

            const totalFee = ethers.parseEther(config.maxTotalFee);
            await linkToken.approve(this.contract.target, totalFee);

            // Submit request
            const tx = await this.contract.requestAIEvaluationWithApproval(
                [contentHash],
                description,
                0, 0, 0, 0,  // Ignored parameters
                1            // Default class
            );

            console.log("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() + (config.timeoutSeconds * 1000)
            };

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

    async getResult(requestId) {
        const [likelihoods, justificationCID, exists] = 
            await this.contract.getEvaluation(requestId);

        if (!exists) {
            const failed = await this.contract.isFailed(requestId);
            return failed ? 
                { status: 'failed', error: 'Evaluation timed out' } :
                { status: 'pending' };
        }

        return {
            status: 'complete',
            likelihoods: likelihoods.map(l => Number(l)),
            justificationCID,
            confidence: Math.max(...likelihoods.map(l => Number(l))) / 10 // Convert to percentage
        };
    }

    watchEvaluation(requestId) {
        return new Promise((resolve, reject) => {
            const config = this.getConfiguration();
            const timeout = setTimeout(() => {
                cleanup();
                reject(new Error('Evaluation timeout'));
            }, config.timeoutSeconds * 1000);

            const fulfillFilter = this.contract.filters.FulfillAIEvaluation(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
                });
            });

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

// Usage example
async function moderateContent(contentHash) {
    const evaluator = new SimpleEvaluator(CONTRACT_ADDRESS, signer);

    try {
        const submission = await evaluator.submitEvaluation(contentHash, "Moderation check");
        console.log("Submitted:", submission.requestId);

        const result = await evaluator.watchEvaluation(submission.requestId);
        console.log("Result:", result);

        return result.likelihoods[0] > 500; // Approve if > 50%

    } catch (error) {
        console.error("Moderation failed:", error);
        return false; // Reject on error
    }
}

// Deployment script for different networks
const deploymentConfigs = {
    'base-sepolia': {
        linkToken: '0xE4aB69C077896252FAFBD49EFD26B5D171A32410',
        oracle: '0x...', // Your ArbiterOperator address
        jobId: '0x...', // Your job ID
        fee: ethers.parseEther('0.01'),
        requiredClass: 1
    },
    'sepolia': {
        linkToken: '0x779877A7B0D9E8603169DdbD7836e478b4624789',
        oracle: '0x...', // Your ArbiterOperator address
        jobId: '0x...', // Your job ID
        fee: ethers.parseEther('0.005'),
        requiredClass: 1
    }
};

async function deploySimpleContract(network) {
    const config = deploymentConfigs[network];
    if (!config) throw new Error(`No config for network: ${network}`);

    const SimpleContract = await ethers.getContractFactory("SimpleContract");
    const contract = await SimpleContract.deploy(
        config.oracle,
        config.jobId,
        config.fee,
        config.linkToken,
        config.requiredClass
    );

    await contract.waitForDeployment();

    console.log(`SimpleContract deployed to: ${contract.target}`);
    console.log(`Configuration:`, config);

    return contract;
}

// Test configuration
async function testSimpleContract(contractAddress) {
    const contract = new ethers.Contract(contractAddress, ABI, provider);

    const [oracle, link, jobId, fee] = await contract.getContractConfig();
    const maxFee = await contract.maxTotalFee(0);
    const timeout = await contract.responseTimeoutSeconds();

    console.log('Configuration:', {
        oracle,
        linkToken: link,
        jobId,
        fee: ethers.formatEther(fee),
        maxTotalFee: ethers.formatEther(maxFee),
        timeoutSeconds: Number(timeout)
    });

    // Test with minimal request
    const testCids = ['QmTest123'];
    const linkToken = new ethers.Contract(link, LINK_ABI, signer);

    await linkToken.approve(contractAddress, maxFee);
    const tx = await contract.requestAIEvaluationWithApproval(
        testCids, '', 0, 0, 0, 0, 1
    );

    console.log('Test request submitted:', tx.hash);
}