Render Network深度解析：好莱坞级VFX的链上众包模式

class RenderJobConfig:
    def __init__(self):
        self.resolution = (3840, 2160)
        self.samples_per_pixel = 256
        self.max_gpu_hours = 1000
        self.max_price_per_gpu_hour = 0.75
        self.priority = "standard"
        self.verification_level = 3
        self.film_grain_intensity = 0.02
        self.denoiser = "optix"
        self.color_space = "ACEScg"
        self.output_format = "exr"
        self.bit_depth = 32

class NodeSelector:
    def __init__(self, network):
        self.network = network
        self.min_reputation = 75
        self.max_latency_ms = 200

    def select_nodes(self, job_config):
        available_nodes = self.network.get_active_nodes()
        qualified = [
            node for node in available_nodes
            if node.reputation >= self.min_reputation
            and node.gpu_vram >= 12
            and node.latency_ms <= self.max_latency_ms
            and node.price_per_hour <= job_config.max_price_per_gpu_hour
        ]
        scored = sorted(qualified, key=lambda n: self._score(n, job_config), reverse=True)
        total_frames = job_config.max_gpu_hours
        selected = scored[:min(len(scored), total_frames)]
        return selected

    def _score(self, node, config):
        perf_score = node.gpu_benchmark / 10000
        rep_score = node.reputation / 100
        price_score = 1 - (node.price_per_hour / config.max_price_per_gpu_hour)
        latency_score = 1 - (node.latency_ms / self.max_latency_ms)
        return perf_score * 0.35 + rep_score * 0.30 + price_score * 0.25 + latency_score * 0.10

class JobDispatcher:
    def __init__(self, network, selector):
        self.network = network
        self.selector = selector

    def dispatch(self, scene_url, config):
        nodes = self.selector.select_nodes(config)
        frames = list(range(1, config.max_gpu_hours + 1))
        chunks = self._split_frames(frames, len(nodes))
        assignments = []
        for node, chunk in zip(nodes, chunks):
            assignment = self.network.submit_task(
                node_address=node.address,
                scene_url=scene_url,
                frame_range=(chunk[0], chunk[-1]),
                config=config.__dict__,
                deadline=self._calc_deadline(config)
            )
            assignments.append(assignment)
        return assignments

    def _split_frames(self, frames, num_chunks):
        chunk_size = len(frames) // num_chunks
        remainder = len(frames) % num_chunks
        chunks = []
        start = 0
        for i in range(num_chunks):
            end = start + chunk_size + (1 if i < remainder else 0)
            chunks.append(frames[start:end])
            start = end
        return chunks

    def _calc_deadline(self, config):
        import time
        base_seconds = config.max_gpu_hours * 3600 / 10
        if config.priority == "priority":
            base_seconds *= 0.5
        return int(time.time() + base_seconds)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

interface IERC20 {
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function transfer(address to, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

contract RenderNetwork {
    enum JobState { Created, Assigned, Rendering, Verifying, Completed, Disputed, Cancelled }

    struct RenderJob {
        address creator;
        address nodeOperator;
        uint256 pricePerFrame;
        uint256 totalFrames;
        uint256 completedFrames;
        uint256 deadline;
        uint256 verificationHash;
        JobState state;
        uint256 escrowAmount;
        uint256 createdAt;
    }

    struct NodeInfo {
        address operator;
        uint256 gpuScore;
        uint256 reputation;
        uint256 totalJobsCompleted;
        uint256 activeJobs;
        uint256 pricePerFrame;
        bool isActive;
        uint256 lastSeen;
    }

    uint256 public jobCounter;
    IERC20 public immutable token;
    uint256 public platformFeeBps;
    address public treasury;

    mapping(uint256 => RenderJob) public jobs;
    mapping(address => NodeInfo) public nodes;
    mapping(address => uint256[]) public nodeJobHistory;

    event JobCreated(uint256 indexed jobId, address indexed creator, uint256 totalFrames, uint256 maxPrice);
    event JobAssigned(uint256 indexed jobId, address indexed nodeOperator);
    event FramesSubmitted(uint256 indexed jobId, uint256 completedFrames);
    event JobCompleted(uint256 indexed jobId, uint256 totalPaid);
    event JobDisputed(uint256 indexed jobId, string reason);
    event NodeRegistered(address indexed operator, uint256 gpuScore, uint256 pricePerFrame);
    event NodeSlashed(address indexed operator, uint256 penaltyAmount);

    error InsufficientPayment();
    error JobNotActive();
    error DeadlineExceeded();
    error Unauthorized();
    error InvalidState();

    modifier onlyJobCreator(uint256 jobId) {
        if (jobs[jobId].creator != msg.sender) revert Unauthorized();
        _;
    }

    constructor(address _token, address _treasury, uint256 _feeBps) {
        token = IERC20(_token);
        treasury = _treasury;
        platformFeeBps = _feeBps;
    }

    function createJob(
        uint256 totalFrames,
        uint256 pricePerFrame,
        uint256 durationHours
    ) external returns (uint256) {
        uint256 totalCost = totalFrames * pricePerFrame;
        if (!token.transferFrom(msg.sender, address(this), totalCost)) revert InsufficientPayment();

        uint256 jobId = ++jobCounter;
        jobs[jobId] = RenderJob({
            creator: msg.sender,
            nodeOperator: address(0),
            pricePerFrame: pricePerFrame,
            totalFrames: totalFrames,
            completedFrames: 0,
            deadline: block.timestamp + durationHours * 1 hours,
            verificationHash: 0,
            state: JobState.Created,
            escrowAmount: totalCost,
            createdAt: block.timestamp
        });

        emit JobCreated(jobId, msg.sender, totalFrames, pricePerFrame);
        return jobId;
    }

    function registerNode(uint256 gpuScore, uint256 pricePerFrame) external {
        nodes[msg.sender] = NodeInfo({
            operator: msg.sender,
            gpuScore: gpuScore,
            reputation: 100,
            totalJobsCompleted: 0,
            activeJobs: 0,
            pricePerFrame: pricePerFrame,
            isActive: true,
            lastSeen: block.timestamp
        });
        emit NodeRegistered(msg.sender, gpuScore, pricePerFrame);
    }

    function acceptJob(uint256 jobId) external {
        RenderJob storage job = jobs[jobId];
        if (job.state != JobState.Created) revert InvalidState();
        if (block.timestamp > job.deadline) revert DeadlineExceeded();
        NodeInfo storage node = nodes[msg.sender];
        if (!node.isActive || node.reputation < 40) revert Unauthorized();

        job.nodeOperator = msg.sender;
        job.state = JobState.Assigned;
        node.activeJobs += 1;

        emit JobAssigned(jobId, msg.sender);
    }

    function submitFrames(uint256 jobId, uint256 frameCount, bytes32 outputHash) external {
        RenderJob storage job = jobs[jobId];
        if (job.nodeOperator != msg.sender) revert Unauthorized();
        if (job.state != JobState.Assigned && job.state != JobState.Rendering) revert InvalidState();
        if (block.timestamp > job.deadline) revert DeadlineExceeded();

        job.completedFrames += frameCount;
        job.state = JobState.Rendering;

        if (job.completedFrames >= job.totalFrames) {
            job.verificationHash = uint256(outputHash);
            job.state = JobState.Verifying;
        }

        emit FramesSubmitted(jobId, job.completedFrames);
    }

    function confirmJob(uint256 jobId) external onlyJobCreator(jobId) {
        RenderJob storage job = jobs[jobId];
        if (job.state != JobState.Verifying) revert InvalidState();

        job.state = JobState.Completed;
        nodes[job.nodeOperator].activeJobs -= 1;

        uint256 fee = (job.escrowAmount * platformFeeBps) / 10000;
        uint256 payment = job.escrowAmount - fee;

        token.transfer(treasury, fee);
        token.transfer(job.nodeOperator, payment);

        emit JobCompleted(jobId, payment);
    }

    function disputeJob(uint256 jobId, string calldata reason) external onlyJobCreator(jobId) {
        RenderJob storage job = jobs[jobId];
        if (job.state != JobState.Verifying) revert InvalidState();
        job.state = JobState.Disputed;
        emit JobDisputed(jobId, reason);
    }

    function cancelJob(uint256 jobId) external onlyJobCreator(jobId) {
        RenderJob storage job = jobs[jobId];
        if (job.state != JobState.Created) revert InvalidState();
        job.state = JobState.Cancelled;
        token.transfer(job.creator, job.escrowAmount);
    }
}

const fetch = require('node-fetch');
const fs = require('fs');
const path = require('path');

const BASE_URL = "https://api.rendernetwork.io/v2";

class RenderClient {
    constructor(apiKey, walletAddress) {
        this.apiKey = apiKey;
        this.walletAddress = walletAddress;
        this.headers = {
            "Authorization": `Bearer ${apiKey}`,
            "Content-Type": "application/json"
        };
    }

    async submitJob({ sceneUrl, frameCount, resolution, samples, tier, renderer }) {
        const payload = {
            scene: sceneUrl,
            frames: frameCount,
            resolution: [resolution.width, resolution.height],
            samples: samples || 256,
            tier: tier || "standard",
            renderer: renderer || "octane",
            output_format: "exr",
            max_gpu_hours: this._estimateGpuHours(frameCount, resolution, samples),
            callback_url: `https://studio.example.com/webhook/${this.walletAddress}`,
            denoiser: "optix",
            color_space: "ACEScg"
        };
        const response = await fetch(`${BASE_URL}/jobs`, {
            method: "POST",
            headers: this.headers,
            body: JSON.stringify(payload)
        });
        if (!response.ok) throw new Error(`HTTP ${response.status}`);
        const data = await response.json();
        return { jobId: data.job_id, estimatedCost: data.estimated_cost, eta: data.eta_seconds };
    }

    async getJobStatus(jobId) {
        const response = await fetch(`${BASE_URL}/jobs/${jobId}`, { headers: this.headers });
        if (!response.ok) throw new Error(`HTTP ${response.status}`);
        return response.json();
    }

    async monitorJob(jobId, intervalMs = 30000) {
        return new Promise((resolve, reject) => {
            const poll = setInterval(async () => {
                try {
                    const status = await this.getJobStatus(jobId);
                    const progress = (status.frames_completed / status.total_frames * 100).toFixed(1);
                    console.log(`[${jobId}] ${progress}% | State: ${status.state} | ETA: ${status.eta_seconds}s`);
                    if (status.state === "completed") {
                        clearInterval(poll);
                        resolve(status);
                    } else if (status.state === "failed") {
                        clearInterval(poll);
                        reject(new Error(`Job failed: ${status.error}`));
                    }
                } catch (err) {
                    clearInterval(poll);
                    reject(err);
                }
            }, intervalMs);
        });
    }

    async downloadFrames(jobId, outputDir) {
        const response = await fetch(`${BASE_URL}/jobs/${jobId}/downloads`, { headers: this.headers });
        const { files } = await response.json();
        const results = [];
        for (const file of files) {
            const fileResponse = await fetch(file.url);
            const buffer = await fileResponse.buffer();
            const filePath = path.join(outputDir, file.name);
            fs.writeFileSync(filePath, buffer);
            results.push(filePath);
        }
        return results;
    }

    _estimateGpuHours(frameCount, resolution, samples) {
        const pixelsPerFrame = resolution.width * resolution.height;
        const baseHoursPerFrame = (pixelsPerFrame / (1920 * 1080)) * 2.0;
        const sampleMultiplier = (samples || 256) / 256;
        return Math.round(frameCount * baseHoursPerFrame * sampleMultiplier);
    }

    static estimateCost(frameCount, resolution, samples, tier) {
        const pixelsPerFrame = resolution.width * resolution.height;
        const baseHoursPerFrame = (pixelsPerFrame / (1920 * 1080)) * 2.0;
        const sampleMultiplier = samples / 256;
        const totalGpuHours = frameCount * baseHoursPerFrame * sampleMultiplier;
        const priceMap = { priority: 1.5, standard: 0.75, economy: 0.40 };
        const estimatedRndR = totalGpuHours * (priceMap[tier] || 0.75);
        return { totalGpuHours: +totalGpuHours.toFixed(2), estimatedRNDR: +estimatedRndr.toFixed(2), tier };
    }
}

async function main() {
    const client = new RenderClient("rn_sk_live_xxx", "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgHU4");
    const cost = RenderClient.estimateCost(5000, { width: 3840, height: 2160 }, 512, "standard");
    console.log("Cost Estimate:", JSON.stringify(cost, null, 2));
    const result = await client.submitJob({
        sceneUrl: "ipfs://QmSceneFileHash/action_seq_v4.orbx",
        frameCount: 5000,
        resolution: { width: 3840, height: 2160 },
        samples: 512,
        tier: "standard",
        renderer: "octane"
    });
    console.log("Job Submitted:", result);
    const finalStatus = await client.monitorJob(result.jobId);
    const frames = await client.downloadFrames(result.jobId, "./output/frames");
    console.log(`Downloaded ${frames.length} frames to ./output/frames`);
}

main().catch(console.error);