比特币矿工转型AI算力：从哈希战争到GPU渲染农场

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

/**
 * @title RenderTaskMarket
 * @notice 去中心化渲染任务的撮合、验收与结算合约
 * @dev 矿工转型GPU节点可在此挂单算力，影视工作室可发布渲染任务
 */
contract RenderTaskMarket {
    enum TaskState { Posted, Assigned, Submitted, Verified, Disputed, Settled }

    struct RenderTask {
        address client;          // 影视工作室/需求方
        address miner;           // GPU节点提供方
        bytes32 sceneHash;       // 场景文件哈希(镜头文件指纹)
        uint256 frameCount;      // 帧数(如2400帧=100秒24fps)
        uint256 reward;          // 任务报酬(以wei计)
        uint256 deadline;        // 截止时间戳
        bytes32 outputHash;      // 渲染结果哈希
        TaskState state;
    }

    mapping(uint256 => RenderTask) public tasks;
    uint256 public nextTaskId;
    address public verifier;      // 验收节点(可由多签/DAO担任)

    event TaskPosted(uint256 indexed taskId, address client, bytes32 sceneHash, uint256 reward);
    event TaskAssigned(uint256 indexed taskId, address miner);
    event TaskSubmitted(uint256 indexed taskId, bytes32 outputHash);
    event TaskVerified(uint256 indexed taskId, bool approved);
    event TaskSettled(uint256 indexed taskId, address miner, uint256 payout);

    constructor(address _verifier) {
        verifier = _verifier;
    }

    /// @notice 工作室发布渲染任务并预存报酬
    function postTask(bytes32 sceneHash, uint256 frameCount, uint256 deadline) external payable returns (uint256 taskId) {
        require(msg.value > 0, "reward required");
        require(deadline > block.timestamp, "deadline invalid");
        taskId = nextTaskId++;
        tasks[taskId] = RenderTask({
            client: msg.sender,
            miner: address(0),
            sceneHash: sceneHash,
            frameCount: frameCount,
            reward: msg.value,
            deadline: deadline,
            outputHash: bytes32(0),
            state: TaskState.Posted
        });
        emit TaskPosted(taskId, msg.sender, sceneHash, msg.value);
    }

    /// @notice 矿工/GPU节点接单
    function claimTask(uint256 taskId) external {
        RenderTask storage t = tasks[taskId];
        require(t.state == TaskState.Posted, "not available");
        require(block.timestamp < t.deadline, "expired");
        t.miner = msg.sender;
        t.state = TaskState.Assigned;
        emit TaskAssigned(taskId, msg.sender);
    }

    /// @notice 矿工提交渲染结果指纹
    function submitResult(uint256 taskId, bytes32 outputHash) external {
        RenderTask storage t = tasks[taskId];
        require(t.state == TaskState.Assigned, "not assigned");
        require(msg.sender == t.miner, "not miner");
        t.outputHash = outputHash;
        t.state = TaskState.Submitted;
        emit TaskSubmitted(taskId, outputHash);
    }

    /// @notice 验收方校验渲染结果(可扩展为多签或链下ZK验证)
    function verifyResult(uint256 taskId, bool approved) external {
        require(msg.sender == verifier, "not verifier");
        RenderTask storage t = tasks[taskId];
        require(t.state == TaskState.Submitted, "not submitted");
        t.state = approved ? TaskState.Verified : TaskState.Disputed;
        emit TaskVerified(taskId, approved);
        if (approved) {
            _settle(taskId);
        }
    }

    /// @notice 结算:将预存报酬释放给矿工
    function _settle(uint256 taskId) internal {
        RenderTask storage t = tasks[taskId];
        require(t.state == TaskState.Verified, "not verified");
        t.state = TaskState.Settled;
        uint256 payout = t.reward;
        // 转账给GPU节点
        (bool ok, ) = payable(t.miner).call{value: payout}("");
        require(ok, "transfer failed");
        emit TaskSettled(taskId, t.miner, payout);
    }

    /// @notice 逾期未交付,工作室可取回预存
    function refundExpired(uint256 taskId) external {
        RenderTask storage t = tasks[taskId];
        require(t.state == TaskState.Assigned, "not assigned");
        require(block.timestamp >= t.deadline, "not expired");
        t.state = TaskState.Settled;
        (bool ok, ) = payable(t.client).call{value: t.reward}("");
        require(ok, "refund failed");
    }
}

"""
render_dispatcher.py
将影视镜头的帧序列分发到GPU渲染集群(Slurm)并跟踪状态
适用于矿企转型后的渲染农场调度层
"""
import subprocess
import json
import time
import hashlib
from pathlib import Path
from dataclasses import dataclass, field
from typing import List, Optional


@dataclass
class RenderShot:
    """单个镜头的渲染任务定义"""
    shot_id: str                      # 镜头编号,如 S042_PRC_0180
    scene_file: str                   # 场景文件路径(.hip/.ma/.nk)
    frame_start: int                  # 起始帧
    frame_end: int                    # 结束帧
    resolution: str = "4096x2160"    # 分辨率(4K DCI)
    gpu_type: str = "h100"            # GPU型号偏好
    gpu_count: int = 1                # 每帧所需GPU数
    priority: int = 50                # 优先级(0-100)
    job_id: Optional[str] = None       # Slurm返回的作业ID
    output_hash: Optional[str] = None # 渲染结果指纹

    def frame_count(self) -> int:
        return self.frame_end - self.frame_start + 1


class SlurmDispatcher:
    """与Slurm调度系统交互的调度器"""

    def __init__(self, partition: str = "gpu_render"):
        self.partition = partition  # Slurm分区(矿企机房的GPU渲染队列)

    def submit_shot(self, shot: RenderShot) -> str:
        """提交一个镜头到渲染队列"""
        script = self._build_script(shot)
        script_path = Path(f"/tmp/render_{shot.shot_id}.sh")
        script_path.write_text(script)

        cmd = [
            "sbatch",
            f"--partition={self.partition}",
            f"--gres=gpu:{shot.gpu_type}:{shot.gpu_count}",
            f"--job-name=render_{shot.shot_id}",
            f"--array=1-{shot.frame_count()}",       # 每帧一个数组任务
            "--output=/data/logs/%x_%A_%a.out",
            str(script_path),
        ]
        result = subprocess.run(cmd, capture_output=True, text=True)
        if result.returncode != 0:
            raise RuntimeError(f"submit failed: {result.stderr}")
        job_id = result.stdout.strip().split()[-1]
        shot.job_id = job_id
        return job_id

    def _build_script(self, shot: RenderShot) -> str:
        """生成渲染调用脚本(以Houdini Karma为例)"""
        return f"""#!/bin/bash
#SBATCH --time=04:00:00
set -e
FRAME=$((SLURM_ARRAY_TASK_ID - 1 + {shot.frame_start}))
echo "[render] shot={shot.shot_id} frame=$FRAME gpu=$CUDA_VISIBLE_DEVICES"
husk --render-context 'karma' \\
     --frame $FRAME \\
     -o /data/renders/{shot.shot_id}/$FRAME.exr \\
     {shot.scene_file}
# 计算输出帧的哈希指纹,供链上验收使用
sha256sum /data/renders/{shot.shot_id}/$FRAME.exr \\
    >> /data/renders/{shot.shot_id}/manifest.sha256
"""

    def status(self, job_id: str) -> dict:
        """查询作业状态"""
        cmd = ["scontrol", "show", "job", job_id, "--json"]
        result = subprocess.run(cmd, capture_output=True, text=True)
        if result.returncode != 0:
            return {"state": "UNKNOWN"}
        info = json.loads(result.stdout)
        return {"state": info["jobs"][0]["job_state"]}


class RenderPipeline:
    """渲染管线:管理多个镜头的批量调度与状态聚合"""

    def __init__(self, dispatcher: SlurmDispatcher):
        self.dispatcher = dispatcher
        self.shots: List[RenderShot] = []

    def add_shot(self, shot: RenderShot):
        self.shots.append(shot)

    def submit_all(self):
        """按优先级排序后批量提交"""
        ordered = sorted(self.shots, key=lambda s: -s.priority)
        for shot in ordered:
            try:
                jid = self.dispatcher.submit_shot(shot)
                print(f"[pipeline] {shot.shot_id} -> job {jid} "
                      f"({shot.frame_count()} frames @ {shot.resolution})")
            except RuntimeError as e:
                print(f"[pipeline] {shot.shot_id} FAILED: {e}")

    def verify_outputs(self, manifest_path: str) -> str:
        """聚合所有帧的哈希,生成镜头级指纹供链上结算"""
        manifest = Path(manifest_path)
        if not manifest.exists():
            return ""
        h = hashlib.sha256()
        for line in manifest.read_text().splitlines():
            digest = line.split()[0]
            h.update(digest.encode())
        return h.hexdigest()


if __name__ == "__main__":
    dispatcher = SlurmDispatcher(partition="gpu_render")
    pipeline = RenderPipeline(dispatcher)

    # 一组待渲染的特效镜头
    pipeline.add_shot(RenderShot("S042_PRC_0180", "/shots/prc0180.hip", 1001, 1240, priority=90))
    pipeline.add_shot(RenderShot("S042_PRC_0181", "/shots/prc0181.hip", 1001, 1080, priority=75))
    pipeline.add_shot(RenderShot("S042_PRC_0182", "/shots/prc0182.hip", 1001, 1440, priority=60))

    pipeline.submit_all()

    # 轮询作业状态(简化版)
    time.sleep(5)
    for shot in pipeline.shots:
        if shot.job_id:
            st = dispatcher.status(shot.job_id)
            print(f"[poll] {shot.shot_id} -> {st['state']}")

    final_hash = pipeline.verify_outputs("/data/renders/S042_PRC_0180/manifest.sha256")
    print(f"[verify] S042_PRC_0180 output hash = 0x{final_hash}")

/**
 * render-client.js
 * 影视工作室侧的链上渲染任务发布与结算客户端
 * 与RenderTaskMarket智能合约交互
 */
const { ethers } = require("ethers");

const RPC_URL = process.env.RPC_URL || "https://mainnet.infura.io/v3/<KEY>";
const PRIVATE_KEY = process.env.RENDER_PK;
const CONTRACT_ADDR = "0xRenderTaskMarket1122334455";

const ABI = [
  "function postTask(bytes32 sceneHash, uint256 frameCount, uint256 deadline) payable returns (uint256)",
  "function claimTask(uint256 taskId) external",
  "function submitResult(uint256 taskId, bytes32 outputHash) external",
  "function verifyResult(uint256 taskId, bool approved) external",
  "function tasks(uint256) view returns (address client, address miner, bytes32 sceneHash, uint256 frameCount, uint256 reward, uint256 deadline, bytes32 outputHash, uint8 state)",
  "event TaskPosted(uint256 taskId, address client, bytes32 sceneHash, uint256 reward)",
  "event TaskSettled(uint256 taskId, address miner, uint256 payout)"
];

async function main() {
  const provider = new ethers.JsonRpcProvider(RPC_URL);
  const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
  const market = new ethers.Contract(CONTRACT_ADDR, ABI, wallet);

  // 1) 工作室发布一个特效镜头渲染任务
  const sceneHash = ethers.id("S042_PRC_0180:v3");        // 场景文件指纹
  const frameCount = 240n;                                 // 240帧(10秒@24fps)
  const deadline = BigInt(Math.floor(Date.now() / 1000) + 6 * 3600); // 6小时后截止
  const reward = ethers.parseEther("0.05");                // 0.05 ETH 报酬

  const tx = await market.postTask(sceneHash, frameCount, deadline, { value: reward });
  const rc = await tx.wait();
  const evt = market.interface.parseLog(rc.logs[0]);
  const taskId = evt.args.taskId;
  console.log(`[studio] posted task ${taskId}, reward ${ethers.formatEther(reward)} ETH`);

  // 2) 监听矿工接单、提交、结算事件
  market.on("TaskAssigned", (tid, miner) => {
    console.log(`[event] task ${tid} assigned to miner ${miner}`);
  });
  market.on("TaskSubmitted", (tid, outputHash) => {
    console.log(`[event] task ${tid} submitted, outputHash=${outputHash}`);
  });
  market.on("TaskSettled", (tid, miner, payout) => {
    console.log(`[event] task ${tid} settled, miner ${miner} got ${ethers.formatEther(payout)} ETH`);
  });

  // 3) 周期性检查任务状态(等待验收方自动校验)
  const poll = setInterval(async () => {
    const t = await market.tasks(taskId);
    // state: 0=Posted 1=Assigned 2=Submitted 3=Verified 4=Disputed 5=Settled
    console.log(`[poll] task ${taskId} state=${t.state}`);
    if (Number(t.state) === 5) {
      console.log("[studio] render settled, pipeline complete");
      clearInterval(poll);
      process.exit(0);
    }
  }, 30000);
}

main().catch((e) => { console.error(e); process.exit(1); });