Task Pool

Task Pool

The TaskPoolImplementation is the core task pool contract that manages AI tasks with full metadata support. It handles task creation, assignment, processing, and reward distribution in the Hyra Network.

Overview

The TaskPoolImplementation contract serves as the central hub for AI task management, providing:

• Task Management: Create, assign, and track AI tasks
• Queue Management: Efficient task distribution and queuing
• ZKP Verification: Handle Zero-Knowledge Proof verification
• Reward Distribution: Manage HYRA token rewards for completed tasks
• Integration: Seamless integration with ModelRegistry and TaskRouter

Key Features

Extended Task Structure

• AI-Specific Fields: requestId, modelId, inputData, resultData
• Task Metadata: Complete task information for AI workers
• ZKP Integration: Built-in support for Zero-Knowledge Proofs
• Reward Management: Transparent reward calculation and distribution

Queue Management

• Efficient Distribution: Optimized task assignment algorithms
• Load Balancing: Distribute tasks across multiple workers
• Deadline Management: Handle task expiration and release
• Priority Queuing: Support for task prioritization

ZKP Verification

• Proof Validation: Verify Zero-Knowledge Proofs
• Anti-Cheating: Prevent workers from submitting fake results
• Privacy Protection: Maintain input/output privacy
• Automated Verification: Streamlined verification process

Contract Structure

State Variables

// Task management
mapping(uint256 => Task) public tasks;
mapping(address => uint256) public userActiveTask;
uint256 public taskCounter;

// Pool information
address public owner;
bool public isActive;
string public category;
string public metadata;

// System integration
address public modelRegistry;
address public zkpVerifier;

Data Structures

Task Struct

struct Task {
    uint256 taskId;                // Unique task identifier
    address assignedTo;            // Worker assigned to task
    uint256 reward;                // Reward amount in HYRA
    uint256 deadline;              // Task deadline timestamp
    bool isCompleted;              // Completion status
    bool isVerified;               // Verification status

    // AI-specific fields
    uint256 requestId;             // ModelRegistry request ID
    string modelId;                // AI model identifier
    string inputData;              // Task input data
    string resultData;             // AI result data

    // ZKP fields
    string resultHash;             // Result hash for verification
    bytes zkpProof;                // Zero-Knowledge Proof
    uint256 zkpPublicInput;        // ZKP public input
    uint256 zkpPublicResult;       // ZKP public result
}

Core Functions

Task Management

Add AI Tasks

function addAITasks(
    uint256[] calldata rewards,
    uint256[] calldata requestIds,
    string[] calldata modelIds,
    string[] calldata inputData,
    uint256[] calldata deadlines
) external payable onlyOwnerOrModelRegistry

Parameters:

• rewards: Array of reward amounts in HYRA
• requestIds: Array of ModelRegistry request IDs
• modelIds: Array of AI model identifiers
• inputData: Array of task input data
• deadlines: Array of task deadline timestamps

Access Control: Only owner or ModelRegistry can add tasks

Example:

// Add multiple AI tasks
const rewards = [ethers.parseEther("0.1"), ethers.parseEther("0.2")];
const requestIds = [1, 2];
const modelIds = ["llm-chat-v1", "image-classifier-v1"];
const inputData = ["What is AI?", "Classify this image"];
const deadlines = [Date.now() + 3600, Date.now() + 7200]; // 1 hour, 2 hours

await taskPool.addAITasks(
  rewards,
  requestIds,
  modelIds,
  inputData,
  deadlines,
  { value: ethers.parseEther("0.3") } // Total rewards
);

Claim Task for User

function claimTaskForUser(address user) external returns (uint256 taskId)

Parameters:

• user: Address of the user claiming the task

Returns:

• taskId: ID of the claimed task

Example:

// AI worker claims a task
const taskId = await taskPool.claimTaskForUser(aiWorker.address);
console.log(`Claimed task ID: ${taskId}`);

// Get task details
const task = await taskPool.tasks(taskId);
console.log(`Model ID: ${task.modelId}`);
console.log(`Input: ${task.inputData}`);
console.log(`Reward: ${ethers.formatEther(task.reward)} HYRA`);

Task Submission

Submit Task for User

function submitTaskForUser(
    address user,
    uint256 taskId,
    string calldata resultHash,
    bytes calldata zkpProof,
    uint256 zkpPublicInput,
    uint256 zkpPublicResult,
    string calldata resultData
) external

Parameters:

• user: Address of the user submitting the task
• taskId: ID of the task being submitted
• resultHash: Hash of the result for verification
• zkpProof: Zero-Knowledge Proof
• zkpPublicInput: ZKP public input
• zkpPublicResult: ZKP public result
• resultData: AI result data

Example:

// AI worker submits task result
await taskPool.submitTaskForUser(
  aiWorker.address,
  taskId,
  "0x1234567890abcdef", // Result hash
  "0x1234567890abcdef", // ZKP proof
  123, // ZKP public input
  456, // ZKP public result
  "The capital of France is Paris." // AI result
);

ZKP Verification

Verify and Pay

function verifyAndPay(
    uint256 taskId,
    bool isValid
) external onlyVerifier

Parameters:

• taskId: ID of the task to verify
• isValid: Whether the ZKP proof is valid

Access Control: Only verifiers can verify and pay

Example:

// Verifier validates ZKP proof and pays rewards
await taskPool.connect(verifier).verifyAndPay(taskId, true);

// Check if task is verified
const task = await taskPool.tasks(taskId);
console.log(`Task verified: ${task.isVerified}`);

Task Lifecycle

1. Task Creation

// ModelRegistry creates tasks automatically
await modelRegistry.requestInference("llm-chat-v1", "Hello world");

2. Task Assignment

// AI worker claims task
const taskId = await taskPool.claimTaskForUser(aiWorker.address);

3. Task Processing

// AI worker processes task (off-chain)
const result = await processAITask(task.inputData, task.modelId);

4. Result Submission

// AI worker submits result with ZKP proof
await taskPool.submitTaskForUser(
  aiWorker.address,
  taskId,
  resultHash,
  zkpProof,
  zkpPublicInput,
  zkpPublicResult,
  result
);

5. Verification and Payment

// Verifier validates and pays rewards
await taskPool.connect(verifier).verifyAndPay(taskId, true);

Events

Task Events

event TasksAdded(
    uint256[] taskIds,
    uint256[] requestIds,
    string[] modelIds
);

event TaskClaimed(
    address indexed user,
    uint256 indexed taskId
);

event TaskSubmitted(
    address indexed user,
    uint256 indexed taskId,
    string resultHash
);

event TaskVerified(
    uint256 indexed taskId,
    bool isValid,
    uint256 reward
);

Pool Events

event PoolActivated(address indexed pool);
event PoolDeactivated(address indexed pool);
event PoolFunded(address indexed pool, uint256 amount);

Access Control

Owner Functions

• addAITasks(): Add new AI tasks
• activatePool(): Activate the pool
• deactivatePool(): Deactivate the pool
• setModelRegistry(): Set ModelRegistry address
• setZKPVerifier(): Set ZKP verifier address
• withdrawFunds(): Withdraw pool funds

Verifier Functions

• verifyAndPay(): Verify ZKP proofs and pay rewards

Public Functions

• claimTaskForUser(): Claim tasks
• submitTaskForUser(): Submit task results
• getTask(): Get task details
• getUserActiveTask(): Get user’s active task

Integration with Other Contracts

ModelRegistry Integration

// ModelRegistry creates tasks
await modelRegistry.requestInference(modelId, prompt);

// TaskPool receives tasks automatically
// Results are updated in ModelRegistry

TaskRouter Integration

// TaskRouter helps workers find tasks
const taskId = await taskRouter.claimBestTask();

// TaskRouter submits results
await taskRouter.submitTask(poolAddress, taskId, resultHash, zkpProof, ...);

Error Handling

Custom Errors

error TaskNotFound();           // Task doesn't exist
error TaskAlreadyClaimed();     // Task already claimed
error TaskNotClaimed();         // Task not claimed by user
error TaskExpired();            // Task deadline passed
error InvalidZKPProof();        // ZKP proof is invalid
error InsufficientFunds();      // Not enough funds for rewards
error Unauthorized();           // Access denied

Input Validation

• Task existence checks
• Deadline validation
• ZKP proof validation
• Access control checks

Gas Optimization

Efficient Storage

• Packed structs for gas efficiency
• Minimal storage operations
• Optimized data types

Batch Operations

function addAITasks(
    uint256[] calldata rewards,
    uint256[] calldata requestIds,
    string[] calldata modelIds,
    string[] calldata inputData,
    uint256[] calldata deadlines
) external payable

Custom Errors

• Use custom errors instead of string messages
• Reduced gas costs for error handling

Usage Examples

Complete Workflow

// 1. Create task pool
const taskPool = await TaskPoolImplementation.deploy();

// 2. Add AI tasks
await taskPool.addAITasks(
  [ethers.parseEther("0.1")],
  [1],
  ["llm-chat-v1"],
  ["What is AI?"],
  [Date.now() + 3600],
  { value: ethers.parseEther("0.1") }
);

// 3. AI worker claims task
const taskId = await taskPool.claimTaskForUser(aiWorker.address);

// 4. AI worker processes task
const result = await processAITask(task.inputData, task.modelId);

// 5. AI worker submits result
await taskPool.submitTaskForUser(
  aiWorker.address,
  taskId,
  resultHash,
  zkpProof,
  zkpPublicInput,
  zkpPublicResult,
  result
);

// 6. Verifier validates and pays
await taskPool.connect(verifier).verifyAndPay(taskId, true);

Security Considerations

Access Control

• Owner-only task creation
• Verifier-only ZKP validation
• Proper authorization checks

Reentrancy Protection

• All external functions use ReentrancyGuard
• Safe external calls

ZKP Verification

• Cryptographic proof validation
• Anti-cheating mechanisms
• Privacy protection

Next Steps

Ready to learn about other smart contracts? Check out:

• Model Registry - Learn about AI model management
• Task Router - Explore task routing
• Task Pool Factory - Learn about pool creation