Submit Tasks

Submit Tasks

Learn how to submit your completed AI inference tasks with Zero-Knowledge Proofs (ZKP) to earn HYRA tokens in the Hyra Network.

Submission Process

The task submission process involves:

1. Validating Results: Ensure your AI results are accurate and complete
2. ZKP Proof Generation: Create cryptographic proof of your computation
3. Submitting to Smart Contract: Submit result and proof to blockchain
4. Verification: Verifiers validate your proof and pay rewards
5. Receiving HYRA Tokens: Get paid for successful task completion

How to Submit Tasks

1. Validate Your Results

Before submission, ensure your results are valid:

from hyra_sdk import HyraClient

# Initialize client
client = HyraClient()

# Validate your result
def validate_result(result, task):
    # Check result format
    if not isinstance(result, str):
        return False

    # Check result length
    if len(result) < 10:
        return False

    # Check for common errors
    error_indicators = ["error", "failed", "invalid"]
    if any(indicator in result.lower() for indicator in error_indicators):
        return False

    return True

# Validate before submission
if not validate_result(result, task):
    raise ValueError("Invalid result")

const { HyraClient } = require("@hyra-network/sdk");

// Initialize client
const client = new HyraClient();

// Validate your result
function validateResult(result, task) {
  // Check result format
  if (typeof result !== "string") {
    return false;
  }

  // Check result length
  if (result.length < 10) {
    return false;
  }

  // Check for common errors
  const errorIndicators = ["error", "failed", "invalid"];
  if (
    errorIndicators.some((indicator) =>
      result.toLowerCase().includes(indicator)
    )
  ) {
    return false;
  }

  return true;
}

// Validate before submission
if (!validateResult(result, task)) {
  throw new Error("Invalid result");
}

2. Submit with ZKP Proof

Submit your completed task with automatic ZKP proof generation:

# Submit task with ZKP proof (handled automatically by SDK)
submit_hash = client.submit_task(
    task['task_id'],
    result,
    task['pool_address']
)
print(f"Submission hash: {submit_hash}")

// Submit task with ZKP proof (handled automatically by SDK)
const submitHash = await client.submitTask(
  task.taskId,
  result,
  task.poolAddress
);
console.log(`Submission hash: ${submitHash}`);

3. Monitor Submission Status

Track your submission status:

# Check submission status
status = client.get_task_status()
if status['has_active_task']:
    print(f"Task still active: {status['active_task_id']}")
else:
    print("Task completed and submitted")

// Check submission status
const status = await client.getTaskStatus();
if (status.hasActiveTask) {
  console.log(`Task still active: ${status.activeTaskId}`);
} else {
  console.log("Task completed and submitted");
}

ZKP Proof System

How ZKP Prevents Cheating

The Zero-Knowledge Proof system ensures you cannot cheat by:

1. Proving Computation: You must generate cryptographic proof you actually ran the AI model
2. Hiding Private Data: Your computation process remains private
3. Verifying Correctness: Verifiers can confirm you did the work without re-running it
4. Preventing Lazy Workers: You cannot submit random results without doing the work

ZKP Generation Process

# The SDK automatically handles ZKP generation
# Here's what happens behind the scenes:

def generate_zkp_proof(input_data, result, model_name):
    # 1. Create circuit for your computation
    circuit = create_computation_circuit(input_data, result, model_name)

    # 2. Generate witness (private computation details)
    witness = create_witness(input_data, result, model_name)

    # 3. Generate proof
    proof = circuit.prove(witness)

    # 4. Return proof and public inputs
    return {
        'proof': proof,
        'public_input': hash(input_data + result),
        'public_output': hash(result)
    }

// The SDK automatically handles ZKP generation
// Here's what happens behind the scenes:

function generateZKPProof(inputData, result, modelName) {
  // 1. Create circuit for your computation
  const circuit = createComputationCircuit(inputData, result, modelName);

  // 2. Generate witness (private computation details)
  const witness = createWitness(inputData, result, modelName);

  // 3. Generate proof
  const proof = circuit.prove(witness);

  // 4. Return proof and public inputs
  return {
    proof: proof,
    publicInput: hash(inputData + result),
    publicOutput: hash(result),
  };
}

Submission Requirements

Required Fields

• Task ID: Unique identifier for the task
• Result: The AI-generated result
• ZKP Proof: Cryptographic proof of computation
• Pool Address: Smart contract address for submission

Automatic ZKP Generation

The SDK automatically handles:

• Proof Generation: Creates ZKP proof of your computation
• Proof Validation: Ensures proof is valid before submission
• Smart Contract Integration: Submits to correct smart contract
• Transaction Management: Handles blockchain transactions

Verification Process

After submission, your task goes through verification:

1. Automated Validation

# System checks for basic validity
def automated_validation(result, task):
    # Check result format
    if not isinstance(result, str):
        return False

    # Check result length
    if len(result) < 10:
        return False

    # Check for common errors
    error_indicators = ["error", "failed", "invalid"]
    if any(indicator in result.lower() for indicator in error_indicators):
        return False

    return True

2. ZKP Proof Verification

# Verifiers validate your ZKP proof
def verify_zkp_proof(proof, public_input, public_output):
    # 1. Verify proof structure
    if not is_valid_proof_structure(proof):
        return False

    # 2. Verify proof against public inputs
    if not verify_proof_against_inputs(proof, public_input):
        return False

    # 3. Verify proof against public outputs
    if not verify_proof_against_outputs(proof, public_output):
        return False

    return True

3. Result Validation

# Cross-validation with other submissions
def cross_validate_result(result, task):
    # Check if result is reasonable for the task
    if not is_reasonable_result(result, task):
        return False

    # Check if result matches expected format
    if not matches_expected_format(result, task):
        return False

    return True

4. Final Approval

# Network consensus on result acceptance
def final_approval(result, proof, task):
    # All validations must pass
    if not automated_validation(result, task):
        return False

    if not verify_zkp_proof(proof, task['public_input'], task['public_output']):
        return False

    if not cross_validate_result(result, task):
        return False

    return True

Rewards System

HYRA Token Rewards

Upon successful verification, you’ll receive:

• HYRA Tokens: Primary network currency
• Gas Fee Coverage: Automatic gas fee handling
• Immediate Payment: Rewards paid automatically upon verification
• Transparent Pricing: Clear reward structure

Reward Calculation

# Calculate your potential rewards
def calculate_rewards(task):
    base_reward = task['reward']
    gas_fees = estimate_gas_fees()
    net_reward = base_reward - gas_fees

    return {
        'base_reward': base_reward,
        'gas_fees': gas_fees,
        'net_reward': net_reward
    }

// Calculate your potential rewards
function calculateRewards(task) {
  const baseReward = task.reward;
  const gasFees = estimateGasFees();
  const netReward = baseReward - gasFees;

  return {
    baseReward: baseReward,
    gasFees: gasFees,
    netReward: netReward,
  };
}

Error Handling

Common Submission Errors

try:
    submit_hash = client.submit_task(task_id, result, pool_address)
except Exception as e:
    if "TaskDeadlinePassed" in str(e):
        print("Task deadline has passed")
    elif "InvalidResult" in str(e):
        print("Invalid result format")
    elif "ZKPProofFailed" in str(e):
        print("ZKP proof generation failed")
    elif "InsufficientBalance" in str(e):
        print("Insufficient HYRA balance for gas fees")
    else:
        print(f"Submission error: {e}")

try {
  const submitHash = await client.submitTask(taskId, result, poolAddress);
} catch (error) {
  if (error.message.includes("TaskDeadlinePassed")) {
    console.log("Task deadline has passed");
  } else if (error.message.includes("InvalidResult")) {
    console.log("Invalid result format");
  } else if (error.message.includes("ZKPProofFailed")) {
    console.log("ZKP proof generation failed");
  } else if (error.message.includes("InsufficientBalance")) {
    console.log("Insufficient HYRA balance for gas fees");
  } else {
    console.log(`Submission error: ${error.message}`);
  }
}

Privacy and Security

Encrypted Submission

• Input Encryption: Task inputs encrypted before submission
• Output Encryption: Results encrypted during transmission
• ZKP Privacy: Zero-knowledge proofs verify computation without revealing process
• No Data Leakage: Your AI model and computation process remain private

Security Best Practices

# Always validate and sanitize results before submission
def sanitize_result(result):
    # Remove any sensitive information
    sanitized = result.replace("password", "***")
    sanitized = sanitized.replace("token", "***")

    # Ensure result is safe for submission
    return sanitized

# Use sanitized result for submission
sanitized_result = sanitize_result(result)
submit_hash = client.submit_task(task_id, sanitized_result, pool_address)

// Always validate and sanitize results before submission
function sanitizeResult(result) {
  // Remove any sensitive information
  let sanitized = result.replace(/password/gi, "***");
  sanitized = sanitized.replace(/token/gi, "***");

  // Ensure result is safe for submission
  return sanitized;
}

// Use sanitized result for submission
const sanitizedResult = sanitizeResult(result);
const submitHash = await client.submitTask(
  taskId,
  sanitizedResult,
  poolAddress
);

Best Practices

For Task Submission

• Validate Results: Always check your results before submission
• Meet Deadlines: Submit before task deadline expires
• Quality Control: Ensure your AI results are accurate and relevant
• Monitor Status: Track your submission status and verification
• Handle Errors: Implement proper error handling and recovery

For ZKP Proofs

• Test Your Setup: Verify ZKP generation works before claiming tasks
• Monitor Performance: Track proof generation time and success rate
• Stay Updated: Keep your ZKP libraries and SDKs updated
• Secure Storage: Protect your private keys and computational resources

Next Steps

Learn how to monitor your rewards and track your HYRA token earnings.