AI Compute Rewards

Total Rewards <= Total Value Created
Quality Score >= Minimum Threshold for Rewards
Stake >= Minimum Bond (anti-Sybil)

HCU = weighted_sum(
    gpu_flops_normalized * w_gpu,
    cpu_cycles_normalized * w_cpu,
    memory_bandwidth_normalized * w_mem,
    storage_iops_normalized * w_storage,
    network_bandwidth_normalized * w_net
)

pub struct ContributionMetrics {
    // Capacity metrics (what you can provide)
    pub total_capacity_hcu: f64,
    pub available_capacity_hcu: f64,

    // Utilization metrics (what was actually used)
    pub utilized_hcu_hours: f64,
    pub jobs_completed: u64,
    pub jobs_failed: u64,

    // Quality metrics (how well you performed)
    pub average_latency_ms: f64,
    pub throughput_tokens_per_sec: f64,
    pub sla_compliance_rate: f64,  // 0.0 - 1.0

    // Uptime metrics (reliability)
    pub uptime_seconds: u64,
    pub total_registered_seconds: u64,
    pub consecutive_heartbeats: u64,

    // Attestation (trust)
    pub nvtrust_attested: bool,
    pub hardware_verified: bool,
    pub last_attestation_timestamp: u64,
}

pub struct AttestationProof {
    // From HIP-006 SPDMEvidence
    pub spdm_evidence: SPDMEvidence,

    // Hardware identity
    pub device_id: [u8; 32],
    pub gpu_model: String,
    pub compute_capability: u32,
    pub vram_gb: u32,

    // Attested capacity
    pub attested_capacity_hcu: f64,

    // Timestamp and signature
    pub timestamp: u64,
    pub nvtrust_signature: Vec<u8>,
}

contract ContributionRegistry {
    struct ProviderContribution {
        address provider;
        bytes32 hardwareId;           // NVTrust device ID
        uint256 totalHcuHours;        // Lifetime HCU-hours
        uint256 currentEpochHcuHours; // This epoch's contribution
        uint256 qualityScore;         // 0-10000 (100.00%)
        uint256 trustScore;           // Hardware trust (0-100)
        uint256 uptimeRatio;          // 0-10000 (100.00%)
        uint256 lastUpdateBlock;
        bool nvtrustVerified;
    }

    mapping(address => ProviderContribution) public contributions;
    mapping(bytes32 => bool) public attestedHardware;

    // Submit attested contribution
    function recordContribution(
        bytes calldata attestationProof,
        uint256 hcuHours,
        uint256 jobsCompleted,
        uint256 jobsFailed
    ) external;

    // Update quality metrics (called by PoAI validators)
    function updateQualityScore(
        address provider,
        uint256 newScore,
        bytes calldata poaiProof
    ) external onlyValidator;
}

R_epoch = R_base + R_fees + R_inflation

Where:
  R_base     = Fixed base emission (decreasing over time)
  R_fees     = 20% of HMM trading fees (recycled to providers)
  R_inflation = Controlled inflation (capped at 5% annually)

R_provider = R_epoch * (W_provider / Sum(W_all_providers))

Where W_provider = weighted contribution score:

W_provider = HCU_utilized
           * Quality_multiplier
           * Trust_multiplier
           * Uptime_multiplier
           * Stake_multiplier

Quality_multiplier = 0.5 + 1.5 * (QualityScore / 10000)

QualityScore = weighted_average(
    SLA_compliance * 0.4,      // Meeting latency/throughput SLAs
    Job_success_rate * 0.3,    // completed / (completed + failed)
    PoAI_attestation_score * 0.2,  // Quality from ZIP-002
    Customer_feedback * 0.1    // Optional dispute resolution
)

Trust_multiplier = TrustScore / 100

Where TrustScore from hardware attestation (see table above)

Uptime_multiplier = 0.7 + 0.5 * (UptimeRatio / 10000)

UptimeRatio = uptime_seconds / total_registered_seconds

Stake_multiplier = 1.0 + 0.5 * min(1.0, log(Stake) / log(MAX_STAKE))

MAX_STAKE = 1,000,000 AI (diminishing returns after this)

Quality_multiplier = 0.5 + 1.5 * (8500/10000) = 1.775
Trust_multiplier = 95/100 = 0.95
Uptime_multiplier = 0.7 + 0.5 * (9900/10000) = 1.195
Stake_multiplier = 1.0 + 0.5 * min(1.0, log(100000)/log(1000000)) = 1.417

W_provider = 100 * 1.775 * 0.95 * 1.195 * 1.417 = 285.5

If total network weight is 10,000 and R_epoch = 1,000,000 AI:
R_provider = 1,000,000 * (285.5 / 10,000) = 28,550 AI

                                  ┌─────────────────┐
                                  │   Epoch Timer   │
                                  │   (24 hours)    │
                                  └────────┬────────┘
                                           │
                                           ▼
┌─────────────────┐              ┌─────────────────┐
│  Contribution   │──────────────│   Reward Pool   │
│    Registry     │              │    Calculator   │
└─────────────────┘              └────────┬────────┘
                                           │
         ┌─────────────────────────────────┼─────────────────────────────────┐
         │                                 │                                 │
         ▼                                 ▼                                 ▼
┌─────────────────┐              ┌─────────────────┐              ┌─────────────────┐
│    Provider     │              │    Treasury     │              │      Burn       │
│    Rewards      │              │     (20%)       │              │     (10%)       │
│     (70%)       │              │                 │              │                 │
└────────┬────────┘              └─────────────────┘              └─────────────────┘
         │
         ▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│                              Teleport Bridge                                     │
│                                                                                  │
│   ┌─────────────┐        ┌─────────────┐        ┌─────────────┐                │
│   │ Hanzo EVM   │        │  Zoo EVM    │        │ Lux C-Chain │                │
│   │   36963     │        │   200200    │        │    96369    │                │
│   └─────────────┘        └─────────────┘        └─────────────┘                │
└─────────────────────────────────────────────────────────────────────────────────┘

contract RewardVesting {
    struct VestingSchedule {
        uint256 totalAmount;
        uint256 immediateAmount;    // 50%
        uint256 weeklyAmount;       // 25%
        uint256 monthlyAmount;      // 25%
        uint256 epochTimestamp;
        uint256 claimedAmount;
    }

    mapping(address => VestingSchedule[]) public vestingSchedules;

    function claimAvailable() external returns (uint256 claimed);
    function getClaimableAmount(address provider) external view returns (uint256);
}

enum RewardDestination {
    HanzoEVM,      // Chain 36963 (default)
    ZooEVM,        // Chain 200200
    LuxCChain,     // Chain 96369
    Staking        // Auto-compound to stake
}

function setRewardDestination(RewardDestination dest) external;

Reward Flow:
  Job Payment (via HMM) → 80% to Provider (immediate)
                        → 20% to Reward Pool (epoch distribution)

HMM provides:
  - Real-time compute pricing (psi/theta dynamics)
  - SLA-aware routing (quality-weighted allocation)
  - Fee collection for reward pool

 PoAI provides:
  - TEE attestations for compute correctness
  - Quality scoring (Delta-I, Delta-U metrics)
  - Slashing for fraudulent attestations

 PoAI Bonus:
  R_poai = rho * V_job    where rho <= 0.1 (10% bonus cap)

// From COMPUTE_SCHEMA_DESIGN.md
interface RewardIntegration {
  // Link to compute_usage table
  usageId: string;

  // Reward calculation inputs
  hcuHours: number;
  qualityScore: number;

  // Reward outputs
  baseReward: bigint;
  qualityBonus: bigint;
  poaiBonus: bigint;
  totalReward: bigint;

  // Distribution
  destination: ChainId;
  vestingScheduleId: string;
}

// From HIP-006 MiningBridge
impl RewardDistributor {
    pub async fn distribute_epoch_rewards(
        &self,
        epoch: u64,
        rewards: Vec<ProviderReward>,
    ) -> Result<Vec<TeleportReceipt>, DistributionError> {
        for reward in rewards {
            match reward.destination {
                ChainId::HanzoEVM => self.teleport.to_hanzo(reward).await?,
                ChainId::ZooEVM => self.teleport.to_zoo(reward).await?,
                ChainId::LuxCChain => self.teleport.to_lux(reward).await?,
                ChainId::Staking => self.stake_and_compound(reward).await?,
            }
        }
    }
}

Reward Rate = f(Total Value Created)

Where Value Created = Sum(Job Payments) + Network Utility

Sustainable when:
  Reward Value <= Value Created + Token Price Appreciation