feat(developer-ecosystem): implement bounty and staking system with ZK-proof integration
Phase 1 Implementation Complete: - AgentBounty.sol: Automated bounty board with ZK-proof verification - AgentStaking.sol: Reputation-based yield farming with dynamic APY - BountyIntegration.sol: Cross-contract event handling and auto-verification - Database models: Complete bounty, staking, and ecosystem metrics schemas - REST APIs: Full bounty and staking management endpoints - Services: Business logic for bounty creation, verification, and staking operations - Ecosystem dashboard: Analytics and metrics tracking system Key Features: - Multi-tier bounty system (Bronze, Silver, Gold, Platinum) - Performance-based APY calculation with reputation multipliers - ZK-proof integration with PerformanceVerifier.sol - Automatic bounty completion detection - Comprehensive analytics dashboard - Risk assessment and leaderboards - Real-time metrics and predictions Security Features: - Reentrancy protection on all contracts - Role-based access control - Dispute resolution mechanism - Early unbonding penalties - Platform fee collection Economic Model: - Creation fees: 0.5% - Success fees: 2% - Platform fees: 1% - Staking APY: 5-20% based on performance - Dispute fees: 0.1%
This commit is contained in:
oib
718
contracts/AgentBounty.sol
Normal file
718
contracts/AgentBounty.sol
Normal file
@@ -0,0 +1,718 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
pragma solidity ^0.8.19;
|
||||
|
||||
import "@openzeppelin/contracts/access/Ownable.sol";
|
||||
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
|
||||
import "@openzeppelin/contracts/security/Pausable.sol";
|
||||
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
|
||||
import "./PerformanceVerifier.sol";
|
||||
import "./AIToken.sol";
|
||||
|
||||
/**
|
||||
* @title Agent Bounty System
|
||||
* @dev Automated bounty board for AI agent capabilities with ZK-proof verification
|
||||
* @notice Allows DAO and users to create bounties that are automatically completed when agents submit valid ZK-proofs
|
||||
*/
|
||||
contract AgentBounty is Ownable, ReentrancyGuard, Pausable {
|
||||
|
||||
// State variables
|
||||
IERC20 public aitbcToken;
|
||||
PerformanceVerifier public performanceVerifier;
|
||||
|
||||
uint256 public bountyCounter;
|
||||
uint256 public creationFeePercentage = 50; // 0.5% in basis points
|
||||
uint256 public successFeePercentage = 200; // 2% in basis points
|
||||
uint256 public disputeFeePercentage = 10; // 0.1% in basis points
|
||||
uint256 public platformFeePercentage = 100; // 1% in basis points
|
||||
|
||||
// Bounty tiers
|
||||
enum BountyTier { BRONZE, SILVER, GOLD, PLATINUM }
|
||||
|
||||
// Bounty status
|
||||
enum BountyStatus { CREATED, ACTIVE, SUBMITTED, VERIFIED, COMPLETED, EXPIRED, DISPUTED }
|
||||
|
||||
// Submission status
|
||||
enum SubmissionStatus { PENDING, VERIFIED, REJECTED, DISPUTED }
|
||||
|
||||
// Structs
|
||||
struct Bounty {
|
||||
uint256 bountyId;
|
||||
string title;
|
||||
string description;
|
||||
uint256 rewardAmount;
|
||||
address creator;
|
||||
BountyTier tier;
|
||||
BountyStatus status;
|
||||
bytes32 performanceCriteria; // Hash of performance requirements
|
||||
uint256 minAccuracy;
|
||||
uint256 deadline;
|
||||
uint256 creationTime;
|
||||
uint256 maxSubmissions;
|
||||
uint256 submissionCount;
|
||||
address winningSubmission;
|
||||
bool requiresZKProof;
|
||||
mapping(address => bool) authorizedSubmitters;
|
||||
}
|
||||
|
||||
struct Submission {
|
||||
uint256 submissionId;
|
||||
uint256 bountyId;
|
||||
address submitter;
|
||||
bytes zkProof;
|
||||
bytes32 performanceHash;
|
||||
uint256 accuracy;
|
||||
uint256 responseTime;
|
||||
uint256 submissionTime;
|
||||
SubmissionStatus status;
|
||||
string disputeReason;
|
||||
address verifier;
|
||||
}
|
||||
|
||||
struct BountyStats {
|
||||
uint256 totalBounties;
|
||||
uint256 activeBounties;
|
||||
uint256 completedBounties;
|
||||
uint256 totalValueLocked;
|
||||
uint256 averageReward;
|
||||
uint256 successRate;
|
||||
}
|
||||
|
||||
// Mappings
|
||||
mapping(uint256 => Bounty) public bounties;
|
||||
mapping(uint256 => Submission) public submissions;
|
||||
mapping(uint256 => uint256[]) public bountySubmissions;
|
||||
mapping(address => uint256[]) public userSubmissions;
|
||||
mapping(address => uint256[]) public creatorBounties;
|
||||
mapping(BountyTier => uint256) public tierRequirements;
|
||||
mapping(uint256 => mapping(address => bool)) public hasSubmitted;
|
||||
|
||||
// Arrays
|
||||
uint256[] public activeBountyIds;
|
||||
address[] public authorizedCreators;
|
||||
|
||||
// Events
|
||||
event BountyCreated(
|
||||
uint256 indexed bountyId,
|
||||
string title,
|
||||
uint256 rewardAmount,
|
||||
address indexed creator,
|
||||
BountyTier tier,
|
||||
uint256 deadline
|
||||
);
|
||||
|
||||
event BountySubmitted(
|
||||
uint256 indexed bountyId,
|
||||
uint256 indexed submissionId,
|
||||
address indexed submitter,
|
||||
bytes32 performanceHash,
|
||||
uint256 accuracy
|
||||
);
|
||||
|
||||
event BountyVerified(
|
||||
uint256 indexed bountyId,
|
||||
uint256 indexed submissionId,
|
||||
address indexed submitter,
|
||||
bool success,
|
||||
uint256 rewardAmount
|
||||
);
|
||||
|
||||
event BountyCompleted(
|
||||
uint256 indexed bountyId,
|
||||
address indexed winner,
|
||||
uint256 rewardAmount,
|
||||
uint256 completionTime
|
||||
);
|
||||
|
||||
event BountyExpired(
|
||||
uint256 indexed bountyId,
|
||||
uint256 refundAmount
|
||||
);
|
||||
|
||||
event BountyDisputed(
|
||||
uint256 indexed bountyId,
|
||||
uint256 indexed submissionId,
|
||||
address indexed disputer,
|
||||
string reason
|
||||
);
|
||||
|
||||
event PlatformFeeCollected(
|
||||
uint256 indexed bountyId,
|
||||
uint256 feeAmount,
|
||||
address indexed collector
|
||||
);
|
||||
|
||||
// Modifiers
|
||||
modifier bountyExists(uint256 _bountyId) {
|
||||
require(_bountyId < bountyCounter, "Bounty does not exist");
|
||||
_;
|
||||
}
|
||||
|
||||
modifier onlyAuthorizedCreator() {
|
||||
require(isAuthorizedCreator(msg.sender), "Not authorized to create bounties");
|
||||
_;
|
||||
}
|
||||
|
||||
modifier validBountyStatus(uint256 _bountyId, BountyStatus _requiredStatus) {
|
||||
require(bounties[_bountyId].status == _requiredStatus, "Invalid bounty status");
|
||||
_;
|
||||
}
|
||||
|
||||
modifier beforeDeadline(uint256 _deadline) {
|
||||
require(block.timestamp <= _deadline, "Deadline passed");
|
||||
_;
|
||||
}
|
||||
|
||||
modifier sufficientBalance(uint256 _amount) {
|
||||
require(aitbcToken.balanceOf(msg.sender) >= _amount, "Insufficient balance");
|
||||
_;
|
||||
}
|
||||
|
||||
constructor(address _aitbcToken, address _performanceVerifier) {
|
||||
aitbcToken = IERC20(_aitbcToken);
|
||||
performanceVerifier = PerformanceVerifier(_performanceVerifier);
|
||||
|
||||
// Set tier requirements (minimum reward amounts)
|
||||
tierRequirements[BountyTier.BRONZE] = 100 * 10**18; // 100 AITBC
|
||||
tierRequirements[BountyTier.SILVER] = 500 * 10**18; // 500 AITBC
|
||||
tierRequirements[BountyTier.GOLD] = 1000 * 10**18; // 1000 AITBC
|
||||
tierRequirements[BountyTier.PLATINUM] = 5000 * 10**18; // 5000 AITBC
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Creates a new bounty
|
||||
* @param _title Bounty title
|
||||
* @param _description Detailed description
|
||||
* @param _rewardAmount Reward amount in AITBC tokens
|
||||
* @param _tier Bounty tier
|
||||
* @param _performanceCriteria Hash of performance requirements
|
||||
* @param _minAccuracy Minimum accuracy required
|
||||
* @param _deadline Bounty deadline
|
||||
* @param _maxSubmissions Maximum number of submissions allowed
|
||||
* @param _requiresZKProof Whether ZK-proof is required
|
||||
*/
|
||||
function createBounty(
|
||||
string memory _title,
|
||||
string memory _description,
|
||||
uint256 _rewardAmount,
|
||||
BountyTier _tier,
|
||||
bytes32 _performanceCriteria,
|
||||
uint256 _minAccuracy,
|
||||
uint256 _deadline,
|
||||
uint256 _maxSubmissions,
|
||||
bool _requiresZKProof
|
||||
) external
|
||||
onlyAuthorizedCreator
|
||||
sufficientBalance(_rewardAmount)
|
||||
beforeDeadline(_deadline)
|
||||
nonReentrant
|
||||
returns (uint256)
|
||||
{
|
||||
require(_rewardAmount >= tierRequirements[_tier], "Reward below tier minimum");
|
||||
require(_minAccuracy <= 100, "Invalid accuracy");
|
||||
require(_maxSubmissions > 0, "Invalid max submissions");
|
||||
require(_deadline > block.timestamp, "Invalid deadline");
|
||||
|
||||
uint256 bountyId = bountyCounter++;
|
||||
|
||||
Bounty storage bounty = bounties[bountyId];
|
||||
bounty.bountyId = bountyId;
|
||||
bounty.title = _title;
|
||||
bounty.description = _description;
|
||||
bounty.rewardAmount = _rewardAmount;
|
||||
bounty.creator = msg.sender;
|
||||
bounty.tier = _tier;
|
||||
bounty.status = BountyStatus.CREATED;
|
||||
bounty.performanceCriteria = _performanceCriteria;
|
||||
bounty.minAccuracy = _minAccuracy;
|
||||
bounty.deadline = _deadline;
|
||||
bounty.creationTime = block.timestamp;
|
||||
bounty.maxSubmissions = _maxSubmissions;
|
||||
bounty.submissionCount = 0;
|
||||
bounty.requiresZKProof = _requiresZKProof;
|
||||
|
||||
// Calculate and collect creation fee
|
||||
uint256 creationFee = (_rewardAmount * creationFeePercentage) / 10000;
|
||||
uint256 totalRequired = _rewardAmount + creationFee;
|
||||
|
||||
require(aitbcToken.balanceOf(msg.sender) >= totalRequired, "Insufficient total amount");
|
||||
|
||||
// Transfer tokens to contract
|
||||
require(aitbcToken.transferFrom(msg.sender, address(this), totalRequired), "Transfer failed");
|
||||
|
||||
// Transfer creation fee to DAO treasury (owner for now)
|
||||
if (creationFee > 0) {
|
||||
require(aitbcToken.transfer(owner(), creationFee), "Fee transfer failed");
|
||||
emit PlatformFeeCollected(bountyId, creationFee, owner());
|
||||
}
|
||||
|
||||
// Update tracking arrays
|
||||
activeBountyIds.push(bountyId);
|
||||
creatorBounties[msg.sender].push(bountyId);
|
||||
|
||||
// Activate bounty
|
||||
bounty.status = BountyStatus.ACTIVE;
|
||||
|
||||
emit BountyCreated(bountyId, _title, _rewardAmount, msg.sender, _tier, _deadline);
|
||||
|
||||
return bountyId;
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Submits a solution to a bounty
|
||||
* @param _bountyId Bounty ID
|
||||
* @param _zkProof Zero-knowledge proof (if required)
|
||||
* @param _performanceHash Hash of performance metrics
|
||||
* @param _accuracy Achieved accuracy
|
||||
* @param _responseTime Response time in milliseconds
|
||||
*/
|
||||
function submitBountySolution(
|
||||
uint256 _bountyId,
|
||||
bytes memory _zkProof,
|
||||
bytes32 _performanceHash,
|
||||
uint256 _accuracy,
|
||||
uint256 _responseTime
|
||||
) external
|
||||
bountyExists(_bountyId)
|
||||
validBountyStatus(_bountyId, BountyStatus.ACTIVE)
|
||||
beforeDeadline(bounties[_bountyId].deadline)
|
||||
nonReentrant
|
||||
returns (uint256)
|
||||
{
|
||||
Bounty storage bounty = bounties[_bountyId];
|
||||
|
||||
require(!hasSubmitted[_bountyId][msg.sender], "Already submitted");
|
||||
require(bounty.submissionCount < bounty.maxSubmissions, "Max submissions reached");
|
||||
|
||||
if (bounty.requiresZKProof) {
|
||||
require(_zkProof.length > 0, "ZK-proof required");
|
||||
}
|
||||
|
||||
uint256 submissionId = bounty.submissionCount; // Use count as ID
|
||||
|
||||
Submission storage submission = submissions[submissionId];
|
||||
submission.submissionId = submissionId;
|
||||
submission.bountyId = _bountyId;
|
||||
submission.submitter = msg.sender;
|
||||
submission.zkProof = _zkProof;
|
||||
submission.performanceHash = _performanceHash;
|
||||
submission.accuracy = _accuracy;
|
||||
submission.responseTime = _responseTime;
|
||||
submission.submissionTime = block.timestamp;
|
||||
submission.status = SubmissionStatus.PENDING;
|
||||
|
||||
// Update tracking
|
||||
bounty.submissionCount++;
|
||||
hasSubmitted[_bountyId][msg.sender] = true;
|
||||
bountySubmissions[_bountyId].push(submissionId);
|
||||
userSubmissions[msg.sender].push(submissionId);
|
||||
|
||||
// Auto-verify if ZK-proof is provided
|
||||
if (_zkProof.length > 0) {
|
||||
_verifySubmission(_bountyId, submissionId);
|
||||
}
|
||||
|
||||
emit BountySubmitted(_bountyId, submissionId, msg.sender, _performanceHash, _accuracy);
|
||||
|
||||
return submissionId;
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Manually verifies a submission (oracle or automated)
|
||||
* @param _bountyId Bounty ID
|
||||
* @param _submissionId Submission ID
|
||||
* @param _verified Whether the submission is verified
|
||||
* @param _verifier Address of the verifier
|
||||
*/
|
||||
function verifySubmission(
|
||||
uint256 _bountyId,
|
||||
uint256 _submissionId,
|
||||
bool _verified,
|
||||
address _verifier
|
||||
) external
|
||||
bountyExists(_bountyId)
|
||||
nonReentrant
|
||||
{
|
||||
Bounty storage bounty = bounties[_bountyId];
|
||||
Submission storage submission = submissions[_submissionId];
|
||||
|
||||
require(submission.status == SubmissionStatus.PENDING, "Submission not pending");
|
||||
require(submission.bountyId == _bountyId, "Submission bounty mismatch");
|
||||
|
||||
submission.status = _verified ? SubmissionStatus.VERIFIED : SubmissionStatus.REJECTED;
|
||||
submission.verifier = _verifier;
|
||||
|
||||
if (_verified) {
|
||||
// Check if this meets the bounty requirements
|
||||
if (submission.accuracy >= bounty.minAccuracy) {
|
||||
_completeBounty(_bountyId, _submissionId);
|
||||
}
|
||||
}
|
||||
|
||||
emit BountyVerified(_bountyId, _submissionId, submission.submitter, _verified, bounty.rewardAmount);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Disputes a submission
|
||||
* @param _bountyId Bounty ID
|
||||
* @param _submissionId Submission ID
|
||||
* @param _reason Reason for dispute
|
||||
*/
|
||||
function disputeSubmission(
|
||||
uint256 _bountyId,
|
||||
uint256 _submissionId,
|
||||
string memory _reason
|
||||
) external
|
||||
bountyExists(_bountyId)
|
||||
nonReentrant
|
||||
{
|
||||
Bounty storage bounty = bounties[_bountyId];
|
||||
Submission storage submission = submissions[_submissionId];
|
||||
|
||||
require(submission.status == SubmissionStatus.VERIFIED, "Can only dispute verified submissions");
|
||||
require(block.timestamp - submission.submissionTime <= 86400, "Dispute window expired"); // 24 hours
|
||||
|
||||
submission.status = SubmissionStatus.DISPUTED;
|
||||
submission.disputeReason = _reason;
|
||||
bounty.status = BountyStatus.DISPUTED;
|
||||
|
||||
// Collect dispute fee
|
||||
uint256 disputeFee = (bounty.rewardAmount * disputeFeePercentage) / 10000;
|
||||
if (disputeFee > 0) {
|
||||
require(aitbcToken.transferFrom(msg.sender, address(this), disputeFee), "Dispute fee transfer failed");
|
||||
}
|
||||
|
||||
emit BountyDisputed(_bountyId, _submissionId, msg.sender, _reason);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Resolves a dispute
|
||||
* @param _bountyId Bounty ID
|
||||
* @param _submissionId Submission ID
|
||||
* @param _upholdDispute Whether to uphold the dispute
|
||||
*/
|
||||
function resolveDispute(
|
||||
uint256 _bountyId,
|
||||
uint256 _submissionId,
|
||||
bool _upholdDispute
|
||||
) external onlyOwner bountyExists(_bountyId) nonReentrant {
|
||||
Bounty storage bounty = bounties[_bountyId];
|
||||
Submission storage submission = submissions[_submissionId];
|
||||
|
||||
require(bounty.status == BountyStatus.DISPUTED, "No dispute to resolve");
|
||||
require(submission.status == SubmissionStatus.DISPUTED, "Submission not disputed");
|
||||
|
||||
if (_upholdDispute) {
|
||||
// Reject the submission
|
||||
submission.status = SubmissionStatus.REJECTED;
|
||||
bounty.status = BountyStatus.ACTIVE;
|
||||
|
||||
// Return dispute fee
|
||||
uint256 disputeFee = (bounty.rewardAmount * disputeFeePercentage) / 10000;
|
||||
if (disputeFee > 0) {
|
||||
require(aitbcToken.transfer(msg.sender, disputeFee), "Dispute fee return failed");
|
||||
}
|
||||
} else {
|
||||
// Uphold the submission
|
||||
submission.status = SubmissionStatus.VERIFIED;
|
||||
_completeBounty(_bountyId, _submissionId);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Expires a bounty and returns funds to creator
|
||||
* @param _bountyId Bounty ID
|
||||
*/
|
||||
function expireBounty(uint256 _bountyId) external bountyExists(_bountyId) nonReentrant {
|
||||
Bounty storage bounty = bounties[_bountyId];
|
||||
|
||||
require(bounty.status == BountyStatus.ACTIVE, "Bounty not active");
|
||||
require(block.timestamp > bounty.deadline, "Deadline not passed");
|
||||
|
||||
bounty.status = BountyStatus.EXPIRED;
|
||||
|
||||
// Return funds to creator
|
||||
uint256 refundAmount = bounty.rewardAmount;
|
||||
require(aitbcToken.transfer(bounty.creator, refundAmount), "Refund transfer failed");
|
||||
|
||||
// Remove from active bounties
|
||||
_removeFromActiveBounties(_bountyId);
|
||||
|
||||
emit BountyExpired(_bountyId, refundAmount);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Authorizes a creator to create bounties
|
||||
* @param _creator Address to authorize
|
||||
*/
|
||||
function authorizeCreator(address _creator) external onlyOwner {
|
||||
require(_creator != address(0), "Invalid address");
|
||||
require(!isAuthorizedCreator(_creator), "Already authorized");
|
||||
|
||||
authorizedCreators.push(_creator);
|
||||
bounties[0].authorizedSubmitters[_creator] = true; // Use bounty 0 as storage
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Revokes creator authorization
|
||||
* @param _creator Address to revoke
|
||||
*/
|
||||
function revokeCreator(address _creator) external onlyOwner {
|
||||
require(isAuthorizedCreator(_creator), "Not authorized");
|
||||
|
||||
bounties[0].authorizedSubmitters[_creator] = false; // Use bounty 0 as storage
|
||||
|
||||
// Remove from array
|
||||
for (uint256 i = 0; i < authorizedCreators.length; i++) {
|
||||
if (authorizedCreators[i] == _creator) {
|
||||
authorizedCreators[i] = authorizedCreators[authorizedCreators.length - 1];
|
||||
authorizedCreators.pop();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Updates fee percentages
|
||||
* @param _creationFee New creation fee percentage
|
||||
* @param _successFee New success fee percentage
|
||||
* @param _platformFee New platform fee percentage
|
||||
*/
|
||||
function updateFees(
|
||||
uint256 _creationFee,
|
||||
uint256 _successFee,
|
||||
uint256 _platformFee
|
||||
) external onlyOwner {
|
||||
require(_creationFee <= 500, "Creation fee too high"); // Max 5%
|
||||
require(_successFee <= 500, "Success fee too high"); // Max 5%
|
||||
require(_platformFee <= 500, "Platform fee too high"); // Max 5%
|
||||
|
||||
creationFeePercentage = _creationFee;
|
||||
successFeePercentage = _successFee;
|
||||
platformFeePercentage = _platformFee;
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Updates tier requirements
|
||||
* @param _tier Bounty tier
|
||||
* @param _minimumReward New minimum reward
|
||||
*/
|
||||
function updateTierRequirement(BountyTier _tier, uint256 _minimumReward) external onlyOwner {
|
||||
tierRequirements[_tier] = _minimumReward;
|
||||
}
|
||||
|
||||
// View functions
|
||||
|
||||
/**
|
||||
* @dev Gets bounty details
|
||||
* @param _bountyId Bounty ID
|
||||
*/
|
||||
function getBounty(uint256 _bountyId) external view bountyExists(_bountyId) returns (
|
||||
string memory title,
|
||||
string memory description,
|
||||
uint256 rewardAmount,
|
||||
address creator,
|
||||
BountyTier tier,
|
||||
BountyStatus status,
|
||||
bytes32 performanceCriteria,
|
||||
uint256 minAccuracy,
|
||||
uint256 deadline,
|
||||
uint256 creationTime,
|
||||
uint256 maxSubmissions,
|
||||
uint256 submissionCount,
|
||||
bool requiresZKProof
|
||||
) {
|
||||
Bounty storage bounty = bounties[_bountyId];
|
||||
return (
|
||||
bounty.title,
|
||||
bounty.description,
|
||||
bounty.rewardAmount,
|
||||
bounty.creator,
|
||||
bounty.tier,
|
||||
bounty.status,
|
||||
bounty.performanceCriteria,
|
||||
bounty.minAccuracy,
|
||||
bounty.deadline,
|
||||
bounty.creationTime,
|
||||
bounty.maxSubmissions,
|
||||
bounty.submissionCount,
|
||||
bounty.requiresZKProof
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Gets submission details
|
||||
* @param _submissionId Submission ID
|
||||
*/
|
||||
function getSubmission(uint256 _submissionId) external view returns (
|
||||
uint256 bountyId,
|
||||
address submitter,
|
||||
bytes32 performanceHash,
|
||||
uint256 accuracy,
|
||||
uint256 responseTime,
|
||||
uint256 submissionTime,
|
||||
SubmissionStatus status,
|
||||
address verifier
|
||||
) {
|
||||
Submission storage submission = submissions[_submissionId];
|
||||
return (
|
||||
submission.bountyId,
|
||||
submission.submitter,
|
||||
submission.performanceHash,
|
||||
submission.accuracy,
|
||||
submission.responseTime,
|
||||
submission.submissionTime,
|
||||
submission.status,
|
||||
submission.verifier
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Gets all submissions for a bounty
|
||||
* @param _bountyId Bounty ID
|
||||
*/
|
||||
function getBountySubmissions(uint256 _bountyId) external view bountyExists(_bountyId) returns (uint256[] memory) {
|
||||
return bountySubmissions[_bountyId];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Gets all bounties created by a user
|
||||
* @param _creator Creator address
|
||||
*/
|
||||
function getCreatorBounties(address _creator) external view returns (uint256[] memory) {
|
||||
return creatorBounties[_creator];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Gets all submissions by a user
|
||||
* @param _submitter Submitter address
|
||||
*/
|
||||
function getUserSubmissions(address _submitter) external view returns (uint256[] memory) {
|
||||
return userSubmissions[_submitter];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Gets all active bounty IDs
|
||||
*/
|
||||
function getActiveBounties() external view returns (uint256[] memory) {
|
||||
return activeBountyIds;
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Gets bounty statistics
|
||||
*/
|
||||
function getBountyStats() external view returns (BountyStats memory) {
|
||||
uint256 totalValue = 0;
|
||||
uint256 activeCount = 0;
|
||||
uint256 completedCount = 0;
|
||||
|
||||
for (uint256 i = 0; i < bountyCounter; i++) {
|
||||
if (bounties[i].status == BountyStatus.ACTIVE) {
|
||||
activeCount++;
|
||||
totalValue += bounties[i].rewardAmount;
|
||||
} else if (bounties[i].status == BountyStatus.COMPLETED) {
|
||||
completedCount++;
|
||||
totalValue += bounties[i].rewardAmount;
|
||||
}
|
||||
}
|
||||
|
||||
uint256 avgReward = bountyCounter > 0 ? totalValue / bountyCounter : 0;
|
||||
uint256 successRate = completedCount > 0 ? (completedCount * 100) / bountyCounter : 0;
|
||||
|
||||
return BountyStats({
|
||||
totalBounties: bountyCounter,
|
||||
activeBounties: activeCount,
|
||||
completedBounties: completedCount,
|
||||
totalValueLocked: totalValue,
|
||||
averageReward: avgReward,
|
||||
successRate: successRate
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Checks if an address is authorized to create bounties
|
||||
* @param _creator Address to check
|
||||
*/
|
||||
function isAuthorizedCreator(address _creator) public view returns (bool) {
|
||||
return bounties[0].authorizedSubmitters[_creator]; // Use bounty 0 as storage
|
||||
}
|
||||
|
||||
// Internal functions
|
||||
|
||||
function _verifySubmission(uint256 _bountyId, uint256 _submissionId) internal {
|
||||
Bounty storage bounty = bounties[_bountyId];
|
||||
Submission storage submission = submissions[_submissionId];
|
||||
|
||||
// Verify ZK-proof using PerformanceVerifier
|
||||
bool proofValid = performanceVerifier.verifyPerformanceProof(
|
||||
0, // Use dummy agreement ID for bounty verification
|
||||
submission.responseTime,
|
||||
submission.accuracy,
|
||||
95, // Default availability
|
||||
100, // Default compute power
|
||||
submission.zkProof
|
||||
);
|
||||
|
||||
if (proofValid && submission.accuracy >= bounty.minAccuracy) {
|
||||
submission.status = SubmissionStatus.VERIFIED;
|
||||
_completeBounty(_bountyId, _submissionId);
|
||||
} else {
|
||||
submission.status = SubmissionStatus.REJECTED;
|
||||
}
|
||||
}
|
||||
|
||||
function _completeBounty(uint256 _bountyId, uint256 _submissionId) internal {
|
||||
Bounty storage bounty = bounties[_bountyId];
|
||||
Submission storage submission = submissions[_submissionId];
|
||||
|
||||
require(bounty.status == BountyStatus.ACTIVE || bounty.status == BountyStatus.SUBMITTED, "Bounty not active");
|
||||
|
||||
bounty.status = BountyStatus.COMPLETED;
|
||||
bounty.winningSubmission = submission.submitter;
|
||||
|
||||
// Calculate fees
|
||||
uint256 successFee = (bounty.rewardAmount * successFeePercentage) / 10000;
|
||||
uint256 platformFee = (bounty.rewardAmount * platformFeePercentage) / 10000;
|
||||
uint256 totalFees = successFee + platformFee;
|
||||
uint256 winnerReward = bounty.rewardAmount - totalFees;
|
||||
|
||||
// Transfer reward to winner
|
||||
if (winnerReward > 0) {
|
||||
require(aitbcToken.transfer(submission.submitter, winnerReward), "Reward transfer failed");
|
||||
}
|
||||
|
||||
// Transfer fees to treasury
|
||||
if (totalFees > 0) {
|
||||
require(aitbcToken.transfer(owner(), totalFees), "Fee transfer failed");
|
||||
emit PlatformFeeCollected(_bountyId, totalFees, owner());
|
||||
}
|
||||
|
||||
// Remove from active bounties
|
||||
_removeFromActiveBounties(_bountyId);
|
||||
|
||||
emit BountyCompleted(_bountyId, submission.submitter, winnerReward, block.timestamp);
|
||||
}
|
||||
|
||||
function _removeFromActiveBounties(uint256 _bountyId) internal {
|
||||
for (uint256 i = 0; i < activeBountyIds.length; i++) {
|
||||
if (activeBountyIds[i] == _bountyId) {
|
||||
activeBountyIds[i] = activeBountyIds[activeBountyIds.length - 1];
|
||||
activeBountyIds.pop();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Emergency pause function
|
||||
*/
|
||||
function pause() external onlyOwner {
|
||||
_pause();
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Unpause function
|
||||
*/
|
||||
function unpause() external onlyOwner {
|
||||
_unpause();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user