פיתוח Turnkey של מערכות מימון ריבועי (QF)

מנגנוני מענקים סטנדרטיים מעוותים את התמיכה הקהילתית האמיתית: תורמים גדולים מקבלים השפעה גבוהה באופן לא פרופורציונלי, בעוד משתתפים קטנים רבים נותרים ללא הכרה. מימון ריבועי (Quadratic Funding) פותר בעיה זו מתמטית — המשקל של כל תרומה גדל כשורש ריבועי של הסכום, כך ש-100 תרומות של $1 מעניקות התאמה (matching) גדולה יותר מתרומה אחת של $100. אנו מפתחים מערכות כאלה במתכונת turnkey: מחוזים חכמים ועד חישובים off-chain עם הגנה מפני התקפות Sybil. הניסיון שלנו: 5+ שנים ב-Web3, עשרות חוזי סבבים מיושמים עבור מערכות אקולוגיות של Arbitrum, Optimism ו-Polygon.

לאחרונה, פרוטוקול DeFi איבד $50k עקב התקפת Sybil על סבב מענקים — התוקף יצר 200 ארנקים ורוקן את מאגר ההתאמה. לאחר פריסת המערכת שלנו עם Gitcoin Passport ו-Connection-weighted QF, התקפות כאלה הפכו לבלתי אפשריות.

היתרון המרכזי של QF הוא בכך שהוא מעודד תמיכה רחבה ולא ריכוז הון. לכן הוא משמש את Gitcoin Grants, Optimism RetroPGF, Arbitrum DAO ומערכות אקולוגיות מרכזיות אחרות.

מהו מימון ריבועי?

הנוסחה הקלאסית להתאמה עבור פרויקט:

matching = (Σ √contributionᵢ)² - Σ contributionᵢ 

הסכום מחושב על כל התורמים של הפרויקט. 100 תרומות של $1 מעניקות התאמה גדולה פי 100 מתרומה אחת של $100. השוו:

ההתאמה הסופית מנורמלת לפי מאגר ההתאמה: אם סכום הציונים עולה על המאגר, כל הסכומים מופחתים באופן יחסי. פרטים נוספים על המנגנון — ויקיפדיה: מימון ריבועי.

אילו בעיות הפתרון שלנו פותר?

התקפות Sybil. ללא הגנה, תוקף יוצר מאות ארנקים, תורם סכומים מינימליים, ומרוקן את מאגר ההתאמה. אנו משתמשים ב-Gitcoin Passport (ציון זהות > 15) וב-Connection-weighted QF (אלגוריתם מ-Gitcoin Grants 19+), שבו תרומות מאשכולות מקבלות משקל נמוך יותר. בנוסף, אנו מיישמים פילטר גיל חשבון ויתרת native מינימלית — זה מפחית את יעילות Sybil ב-90%. הפתרון שלנו טוב פי 3 מפילטר Passport פשוט ללא ניתוח אשכולות — זה שיפור של פי 3 בעמידות ל-Sybil.

דיוק חישוב off-chain. ההתאמה מחושבת עם אריתמטיקה בנקודה קבועה (קנה מידה 1e9) ושורש ריבועי שלם, מה שמבטל שגיאות עיגול. אימות on-chain באמצעות Merkle proof או ZK proof — אנו תומכים בשתי האפשרויות.

עלויות גז. אנו מייעלים תרומות: עיבוד אצווה, שימוש ב-ERC-20 Permit לחתימות, והעברות אצווה במהלך החלוקה. ברשת הבדיקה של Arbitrum, תרומה אחת עולה כ-$0.02.

כיצד אנו מיישמים מימון ריבועי

טכנולוגיות: Solidity 0.8.20+, Foundry, OpenZeppelin, Tenderly, Slither. ל-off-chain — TypeScript, ethers.js, PostgreSQL.

Round Controller — חוזה חכם בסיסי עם תמיכה ב-Merkle proof:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

contract QFRound is Ownable {
    using SafeERC20 for IERC20;

    IERC20 public immutable donationToken;
    uint256 public immutable matchingPool;
    uint256 public immutable roundStart;
    uint256 public immutable roundEnd;

    mapping(uint256 => mapping(address => uint256)) public donations;
    mapping(uint256 => uint256) public projectTotalDonations;
    mapping(uint256 => address[]) public projectDonors;

    bytes32 public matchingMerkleRoot;
    mapping(uint256 => bool) public matchingClaimed;

    event DonationMade(uint256 indexed projectId, address indexed donor, uint256 amount);
    event MatchingDistributed(uint256 indexed projectId, uint256 amount);

    constructor(address _token, uint256 _matchingPool, uint256 _start, uint256 _end) Ownable(msg.sender) {
        donationToken = IERC20(_token);
        matchingPool = _matchingPool;
        roundStart = _start;
        roundEnd = _end;
    }

    function donate(uint256 projectId, uint256 amount) external {
        require(block.timestamp >= roundStart, "Round not started");
        require(block.timestamp <= roundEnd, "Round ended");
        require(amount > 0, "Zero amount");

        if (donations[projectId][msg.sender] == 0) {
            projectDonors[projectId].push(msg.sender);
        }
        donations[projectId][msg.sender] += amount;
        projectTotalDonations[projectId] += amount;
        donationToken.safeTransferFrom(msg.sender, address(this), amount);
        emit DonationMade(projectId, msg.sender, amount);
    }

    function setMatchingRoot(bytes32 _root) external onlyOwner {
        require(block.timestamp > roundEnd, "Round not ended");
        matchingMerkleRoot = _root;
    }

    function claimMatching(uint256 projectId, address recipient, uint256 matchingAmount, bytes32[] calldata proof) external {
        require(!matchingClaimed[projectId], "Already claimed");
        require(matchingMerkleRoot != bytes32(0), "Root not set");

        bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(projectId, recipient, matchingAmount))));
        require(MerkleProof.verify(proof, matchingMerkleRoot, leaf), "Invalid proof");

        matchingClaimed[projectId] = true;
        donationToken.safeTransfer(recipient, matchingAmount);
        emit MatchingDistributed(projectId, matchingAmount);
    }
}

דוגמה לחישוב QF ב-off-chain ב-TypeScript עם אריתמטיקה בנקודה קבועה:

interface Donation {
  projectId: number;
  donor: string;
  amount: bigint;
}

function calculateQFMatching(donations: Donation[], matchingPool: bigint) {
  const projectDonations = new Map<number, Map<string, bigint>>();
  for (const d of donations) {
    if (!projectDonations.has(d.projectId)) projectDonations.set(d.projectId, new Map());
    const donors = projectDonations.get(d.projectId)!;
    donors.set(d.donor, (donors.get(d.donor) ?? 0n) + d.amount);
  }

  const projectScores = new Map<number, bigint>();
  let totalScore = 0n;
  const SCALE = 1_000_000_000n;

  for (const [projectId, donors] of projectDonations) {
    let sumSqrt = 0n;
    for (const amount of donors.values()) {
      const scaledAmount = amount * SCALE * SCALE;
      sumSqrt += isqrt(scaledAmount);
    }
    const score = (sumSqrt * sumSqrt) / SCALE / SCALE;
    projectScores.set(projectId, score);
    totalScore += score;
  }

  if (totalScore === 0n) return [];

  const result = [];
  for (const [projectId, score] of projectScores) {
    const matchingAmount = (score * matchingPool) / totalScore;
    result.push({ projectId, recipient: getProjectRecipient(projectId), matchingAmount });
  }
  return result;
}

function isqrt(n: bigint): bigint {
  if (n < 2n) return n;
  let x = n;
  let y = (x + 1n) / 2n;
  while (y < x) {
    x = y;
    y = (x + n / x) / 2n;
  }
  return x;
}

כיצד להגן על QF מפני התקפות Sybil

Gitcoin Passport — סף מינימלי של 15 נקודות. אימות לפני תרומה:

async function checkPassportScore(address: string): Promise<boolean> {
  const res = await fetch(
    `https://api.scorer.gitcoin.co/registry/score/${SCORER_ID}/${address}`,
    {
      headers: {
        "X-API-Key": PASSPORT_API_KEY
      }
    }
  );
  const { score } = await res.json();
  return parseFloat(score) >= 15.0;
}

Connection-weighted QF (COCM) — מפחית את המשקל של תרומות מאותו אשכול. אנו גם משתמשים ב-Pairwise Coordination Subsidy: אם שני תורמים מצביעים לעתים קרובות לאותם פרויקטים, התרומה המשותפת שלהם נקנסת במקדם של עד 30%. זה יעיל נגד קבוצות מתואמות ללא איסור מלא. שיטת ה-Connection-weighted QF שלנו מפחיתה את יעילות Sybil פי 3 בהשוואה לפילטר Passport פשוט.

למה לבחור בנו

למהנדסים שלנו יש הסמכות Solidity וניסיון עם עשרות סבבי QF. Gitcoin Grants חילקה $50M+ באמצעות QF — השתתפנו בפיתוח כמה מהמערכות הללו.

כיצד ליישם מימון ריבועי

1. ביקורת דרישות ומפרט סבב (מספר פרויקטים, טוקן תרומה, גודל מאגר התאמה, משך).
2. פיתוח חוזים חכמים (Round Controller, Grant Registry, Distribution Engine) תוך התחשבות בשיטת האימות שנבחרה (Merkle או ZK).
3. יישום מנוע חישוב off-chain עם אריתמטיקה בנקודה קבועה ושילוב ספק זהות (Gitcoin Passport, WorldID).
4. כתיבת בדיקות unit ו-fuzz, בדיקות עם Slither ו-Mythril.
5. ביקורת אבטחה של חוזי מפתח עם אימות פורמלי.
6. פריסה לרשת שנבחרה (Ethereum, Polygon, Arbitrum, Optimism) עם הגדרת פרמטרים.
7. שילוב Frontend (React, wagmi, RainbowKit) ו-API לניהול סבבים.
8. ניטור ותמיכה למשך 12 חודשים.

מה כלול בעבודה

• ביקורת דרישות ומפרט סבב
• פיתוח חוזים חכמים (Round Controller, Registry, Distribution)
• יישום מנוע חישוב off-chain עם אימות ZK/Merkle
• שילוב Gitcoin Passport וספקי הגנת Sybil אחרים
• כתיבת בדיקות (unit, fuzz, integration)
• ביקורת אבטחה (Slither, Mythril, סקירת קוד ידנית)
• תיעוד מלא וגישה לקוד מקור
• סיוע בפריסה והדרכה
• 12 חודשי תמיכה

לוח זמנים: משבועיים (MVP עם Merkle proof) ועד חודשיים (מערכת מלאה עם ZK). העלות מחושבת באופן אישי — כתבו לנו ונעריך את הפרויקט שלכם תוך 2 ימי עסקים.

הזמינו פיתוח מערכת QF כבר עכשיו. קבלו ייעוץ — צרו קשר. אנו מבטיחים עמידה בלוחות זמנים ואיכות, המאושרת על ידי 5+ שנות ניסיון ב-Web3.