BountyEscrow

Creator deposits PRIV  -->  Bounty active  -->  Contributors submit data  -->  Oracle approves
        |                        |                       |                          |
        v                        v                       v                          v
  createBounty()           Status: Active         Off-chain data            approveSubmission()
  funds locked             (1-365 days)           tracked by hash          M-of-N consensus
                                                                                   |
                                                                                   v
                                                                          Auto-payout to
                                                                          contributor + fee
                                                                          to FeeManager

function stakeAsCreator(uint256 amount) external nonReentrant whenNotPaused
function unstakeAsCreator(uint256 amount) external nonReentrant

if (bounty.requiredBadgeId != 0 && address(privBadges) != address(0)) {
    if (privBadges.balanceOf(contributor, bounty.requiredBadgeId) == 0)
        revert MissingRequiredBadge();
}

function oracleHeartbeatPing() external  // Only callable by registered oracles

function claimPayouts(uint256[] calldata payoutIndices) external nonReentrant whenNotPaused

function slashPendingPayouts(address contributor) external nonReentrant returns (uint256 slashedAmount)

uint256 public constant STANDARD_FEE_BPS = 300;       // 3%
uint256 public constant STAKED_FEE_BPS = 200;          // 2%
uint256 public constant DIRECT_DISCOUNT_BPS = 1500;    // 15%
uint256 public constant STAKED_DISCOUNT_BPS = 2000;    // 20%
uint256 public constant BPS_DENOMINATOR = 10_000;
uint256 public constant MIN_DURATION = 1 days;
uint256 public constant MAX_DURATION = 365 days;
uint256 public constant MIN_CREATOR_STAKE = 1000e18;   // 1,000 PRIV
uint256 public constant STAKE_LOCK_DURATION = 30 days;
uint256 public constant CANCEL_COOLDOWN = 48 hours;
uint256 public constant MIN_PRICE_PER_SUBMISSION = 10_000_000_000_000_000; // 0.01 PRIV
uint256 public constant ORACLE_STALENESS = 1 hours;

IERC20 public immutable privToken;           // PRIV token contract
IFeeManager public feeManager;               // FeeManagerV2 for fee distribution

uint256 public nextBountyId;
uint256 public nextApprovalId;
uint256 public totalEscrowBalance;           // PRIV currently held in escrow
uint256 public totalPaidToContributors;      // Lifetime payouts
uint256 public totalProtocolFees;            // Lifetime fees
uint256 public totalBountiesCreated;
uint256 public totalCreatorStakes;           // Total staked by creators
uint256 public minOracleConfirmations;       // M-of-N threshold (default: 1)

struct Bounty {
    address creator;
    uint256 totalDeposit;
    uint256 pricePerSubmission;   // Effective price (after discount)
    uint256 targetSubmissions;
    uint256 approvedCount;
    uint256 totalPaidOut;
    uint256 protocolFeePaid;
    uint256 expiresAt;
    uint256 createdAt;
    PaymentTier tier;
    BountyStatus status;
    bytes32 metadataHash;         // IPFS hash of bounty specs
    uint256 requiredBadgeId;      // 0 if no badge required
}

struct PendingPayout {
    uint256 amount;
    uint256 unlockTime;
    bool claimed;
    bool slashed;
}

struct Approval {
    address contributor;
    uint256 bountyId;
    uint256 payout;
    uint256 protocolFee;
    uint256 approvedAt;
    bytes32 submissionHash;
}

function createBounty(
    uint256 pricePerSubmission,
    uint256 targetSubmissions,
    uint256 duration,
    bytes32 metadataHash,
    PaymentTier tier,
    uint256 requiredBadgeId
) external nonReentrant whenNotPaused returns (uint256 bountyId)

function cancelBounty(uint256 bountyId) external nonReentrant

function withdrawRemaining(uint256 bountyId) external nonReentrant

function stakeAsCreator(uint256 amount) external nonReentrant whenNotPaused

function unstakeAsCreator(uint256 amount) external nonReentrant

function claimPayouts(uint256[] calldata payoutIndices) external nonReentrant whenNotPaused

function approveSubmission(
    uint256 bountyId,
    address contributor,
    bytes32 submissionHash
) external nonReentrant whenNotPaused

function oracleHeartbeatPing() external

function getEffectivePrice(uint256 basePrice, PaymentTier tier) external pure returns (uint256)

function getBountyTotalCost(
    uint256 pricePerSubmission,
    uint256 targetSubmissions,
    PaymentTier tier
) external pure returns (uint256 totalCost, uint256 effectivePrice, uint256 totalFees)

function getBountyRemaining(uint256 bountyId) external view returns (uint256)

function isStakedCreator(address creator) external view returns (bool)

function getCreatorBountyCount(address creator) external view returns (uint256)
function getContributorApprovalCount(address contributor) external view returns (uint256)

function addOracle(address oracle) external onlyOwner
function removeOracle(address oracle) external onlyOwner

function setMinOracleConfirmations(uint256 _min) external onlyOwner

function setFeeManager(address _feeManager) external onlyOwner

function setPrivBadges(address _privBadges) external onlyOwner

function setApproverRegistry(address _registry) external onlyOwner

function pause() external onlyOwner
function unpause() external onlyOwner

event BountyCreated(
    uint256 indexed bountyId,
    address indexed creator,
    uint256 totalDeposit,
    uint256 pricePerSubmission,
    uint256 targetSubmissions,
    PaymentTier tier,
    uint256 expiresAt,
    uint256 requiredBadgeId
);

event SubmissionApproved(
    uint256 indexed bountyId,
    uint256 indexed approvalId,
    address indexed contributor,
    uint256 payout,
    uint256 protocolFee
);

event BountyCompleted(uint256 indexed bountyId, uint256 totalPaidOut, uint256 totalFees);
event BountyExpired(uint256 indexed bountyId);
event BountyCancelled(uint256 indexed bountyId, uint256 refunded);
event RemainingWithdrawn(uint256 indexed bountyId, uint256 amount);

event CreatorStaked(address indexed creator, uint256 amount);
event CreatorUnstaked(address indexed creator, uint256 amount);

event OracleAdded(address indexed oracle);
event OracleRemoved(address indexed oracle);
event FeeManagerUpdated(address indexed newFeeManager);

error ZeroAddress();
error ZeroAmount();
error InvalidBountyId();
error BountyNotActive();
error BountyNotExpired();
error InsufficientDeposit();
error TargetAlreadyMet();
error NotBountyCreator();
error NotOracle();
error StaleOracle();               // Oracle heartbeat > 1 hour old
error AlreadyApproved();           // Submission or oracle confirmation duplicate
error InsufficientStake();         // Below 1,000 PRIV for Tier 2
error StakeStillLocked();          // 30-day lock not elapsed
error NothingToWithdraw();
error InvalidTier();
error InvalidDuration();           // Outside 1 day -- 365 days
error InvalidTarget();             // targetSubmissions == 0
error CooldownNotElapsed();        // Cancel before 48h cooldown
error MissingRequiredBadge();      // Contributor lacks required PrivBadge
error NotApproverRegistry();       // Slash caller is not ApproverRegistry
error PayoutStillLocked();         // Timelock not elapsed
error PayoutAlreadyProcessed();    // Payout already claimed or slashed

import { useWriteContract } from 'wagmi'
import { parseEther } from 'viem'

function useCreateBounty() {
  const { writeContract } = useWriteContract()

  return async (
    pricePerSubmission: string,
    targetSubmissions: number,
    durationDays: number,
    metadataHash: `0x${string}`
  ) => {
    const price = parseEther(pricePerSubmission)
    const duration = BigInt(durationDays * 86400)

    // 1. Calculate total deposit needed
    // totalDeposit = (price + price * 300 / 10000) * targetSubmissions
    const fee = (price * 300n) / 10000n
    const totalDeposit = (price + fee) * BigInt(targetSubmissions)

    // 2. Approve PRIV spending
    await writeContract({
      address: PRIV_TOKEN_ADDRESS,
      abi: erc20Abi,
      functionName: 'approve',
      args: [BOUNTY_ESCROW_ADDRESS, totalDeposit],
    })

    // 3. Create bounty (tier 0 = Standard, badgeId 0 = no requirement)
    await writeContract({
      address: BOUNTY_ESCROW_ADDRESS,
      abi: bountyEscrowAbi,
      functionName: 'createBounty',
      args: [price, BigInt(targetSubmissions), duration, metadataHash, 0, 0n],
    })
  }
}

import { useReadContract } from 'wagmi'

function useBountyInfo(bountyId: number) {
  const { data: bounty } = useReadContract({
    address: BOUNTY_ESCROW_ADDRESS,
    abi: bountyEscrowAbi,
    functionName: 'bounties',
    args: [BigInt(bountyId)],
  })

  const { data: remaining } = useReadContract({
    address: BOUNTY_ESCROW_ADDRESS,
    abi: bountyEscrowAbi,
    functionName: 'getBountyRemaining',
    args: [BigInt(bountyId)],
  })

  return { bounty, remaining }
}

import { useWriteContract } from 'wagmi'
import { parseEther } from 'viem'

function useCreatorStake() {
  const { writeContract } = useWriteContract()

  return async (amount: string) => {
    const amountWei = parseEther(amount)

    // 1. Approve PRIV spending
    await writeContract({
      address: PRIV_TOKEN_ADDRESS,
      abi: erc20Abi,
      functionName: 'approve',
      args: [BOUNTY_ESCROW_ADDRESS, amountWei],
    })

    // 2. Stake
    await writeContract({
      address: BOUNTY_ESCROW_ADDRESS,
      abi: bountyEscrowAbi,
      functionName: 'stakeAsCreator',
      args: [amountWei],
    })
  }
}

function useBountyCostEstimate(
  pricePerSubmission: bigint,
  targetSubmissions: number,
  tier: number
) {
  const { data: cost } = useReadContract({
    address: BOUNTY_ESCROW_ADDRESS,
    abi: bountyEscrowAbi,
    functionName: 'getBountyTotalCost',
    args: [pricePerSubmission, BigInt(targetSubmissions), tier],
  })

  // cost = [totalCost, effectivePrice, totalFees]
  return cost
}