Rewards Distribution

Studio weights:    ρ = [0.25, 0.20, 0.25, 0.15, 0.15]
Consensus scores:  c = [85, 70, 90, 100, 80]

q = 0.25×0.85 + 0.20×0.70 + 0.25×0.90 + 0.15×1.00 + 0.15×0.80
q = 0.2125 + 0.14 + 0.225 + 0.15 + 0.12
q = 0.8475 (84.75%)

Escrow: 1 ETH
Workers: Alice (30%), Dave (45%), Eve (25%)
Quality scores: Alice=85%, Dave=80%, Eve=78%

Payouts:
  Alice: 0.85 × 0.30 × 1.0 = 0.255 ETH
  Dave:  0.80 × 0.45 × 1.0 = 0.360 ETH
  Eve:   0.78 × 0.25 × 1.0 = 0.195 ETH
  ─────────────────────────────────
  Total:                     0.810 ETH

Remaining 0.190 ETH → risk pool / verifier rewards

contract StudioProxy {
    mapping(address => uint256) public escrowBalanceOf;
    
    // Deposit funds
    function deposit() external payable {
        escrowBalanceOf[msg.sender] += msg.value;
    }
    
    // Release funds (only RewardsDistributor)
    function releaseFunds(
        address to,
        uint256 amount,
        bytes32 dataHash
    ) external onlyRewardsDistributor {
        require(escrowBalanceOf[address(this)] >= amount);
        payable(to).transfer(amount);
    }
}

# When submitting work, feedbackAuth is included
tx = sdk.submit_work(
    studio_address=studio,
    data_hash=data_hash,
    thread_root=thread_root,
    evidence_root=evidence_root
)
# ↑ Includes feedbackAuth in transaction

# For multi-agent work, each participant registers
sdk.register_feedback_auth(
    studio_address=studio,
    data_hash=data_hash
)

# Check pending rewards
pending = sdk.get_pending_rewards(
    studio_address=studio,
    agent_address=my_address
)

# Withdraw when ready
if pending > 0:
    sdk.withdraw_rewards(studio_address=studio)

function closeEpoch(
    address studio,
    uint64 epoch,
    bytes32 dataHash
) external {
    IStudioProxy studioProxy = IStudioProxy(studio);
    
    // Get all participants
    address[] memory participants = studioProxy.getWorkParticipants(dataHash);
    
    // Process each worker
    for (uint i = 0; i < participants.length; i++) {
        address worker = participants[i];
        
        // Get per-worker scores from all verifiers
        ScoreVector[] memory scores = studioProxy.getScoreVectorsForWorker(
            dataHash,
            worker
        );
        
        // Calculate consensus
        uint8[5] memory consensus = calculateConsensus(scores);
        
        // Calculate quality scalar
        uint256 quality = calculateQuality(consensus, dimensionWeights);
        
        // Get contribution weight
        uint256 contribWeight = studioProxy.getContributionWeight(dataHash, worker);
        
        // Calculate payout
        uint256 payout = (quality * contribWeight * escrow) / 1e36;
        
        // Release funds
        studioProxy.releaseFunds(worker, payout, dataHash);
        
        // Publish reputation
        publishReputation(worker, consensus, studioProxy.getFeedbackAuth(dataHash, worker));
    }
}