The Looming Scalability Wall for On-Chain Grant Proposal Systems

Mechanisms like Gitcoin Grants and Optimism's RPGF are computationally explosive. Evaluating pairwise matches across thousands of contributions on-chain is prohibitively expensive, creating a $1M+ gas cost wall for large rounds.

• Cost Inversion: Admin gas fees can eclipse individual grant sizes.
• Time Inversion: Finalizing results can take days, defeating the purpose of agile funding.
• Scale Limit: Systems cap at ~500 projects before becoming economically unviable.

Fully on-chain voting, as seen in Compound and Uniswap, is a playground for sophisticated attackers. The transparent mempool and delayed execution create arbitrage windows measured in blocks.

• Time-Bandit Attacks: Adversaries front-run or sandwich vote settlements.
• Collusion Markets: Voters can credibly sell their voting power on platforms like Vote Escrow systems.
• Result Finality: A passed proposal isn't safe until execution, allowing last-block reversals.

High-quality grant assessment requires analyzing GitHub commits, financial reports, and impact metrics—data formats that are native off-chain. Forcing this onto L1s like Ethereum or even L2s like Arbitrum is a category error.

• Storage Bloat: Storing due diligence reports on-chain is 1000x more expensive than AWS S3.
• Verification Gap: On-chain votes lack the context to judge off-chain evidence.
• Workflow Fracture: Teams juggle Snapshot, Discourse, and multisig wallets, creating coordination overhead.

Legacy governance models like quadratic voting on Ethereum Mainnet create prohibitive costs. A single proposal with 1000 voters can incur >$10k in gas fees, disenfranchising small contributors and stalling innovation.

• Cost Barrier: Gas fees dominate grant size, making micro-grants impossible.
• Time Inefficiency: Multi-day voting periods and manual execution create >1 week proposal cycles.
• Voter Apathy: High participation cost leads to <5% voter turnout, centralizing decision-making.

Protocols like Optimism's Citizen House and Arbitrum's DAO shift execution and voting to dedicated Layer 2s or sidechains. This separates consensus from execution, slashing costs by >100x.

• Cost Efficiency: Vote and execute grants for <$0.01 per transaction.
• Speed: Finalize votes and trigger payments in ~1 hour, not days.
• Modular Security: Inherits L1 security for treasury holdings while scaling operations.

Massive, single-chain treasuries (e.g., $500M+ in USDC on Ethereum) are capital-inefficient. Funds are locked, earning zero yield, and transparency is limited to on-chain snooping.

• Capital Stagnation: Idle assets fail to offset inflation or generate returns for the DAO.
• Opaque Accounting: Manual tracking of multi-chain grants is error-prone.
• Execution Risk: Large, manual multisig payments are prime targets for social engineering.

Infrastructure like Sablier for streaming and Superfluid for real-time finance enables automated, conditional grant disbursement. This turns static treasuries into active, yield-generating engines.

• Continuous Funding: Stream funds per second based on milestone completion.
• Automated Compliance: KYC/AML checks via Oracles can gate payments.
• Yield Optimization: Treasury assets are automatically deployed to secure DeFi pools (e.g., Aave, Compound) when not disbursed.

Manual review by committee members is slow, subjective, and doesn't scale. Evaluating 100+ proposals per cycle leads to reviewer burnout and inconsistent outcomes.

• Bottleneck: A 5-person committee becomes a single point of failure and censorship.
• Subjectivity: Quality assessment lacks reproducible metrics.
• Slow Feedback: Applicants wait weeks for a binary yes/no with minimal rationale.

Systems like Gitcoin Passport and Orange Protocol create sybil-resistant reputation scores. These credentials automate grant filtering and enable retroactive funding models pioneered by Optimism.

• Automated Triage: Proposals are pre-filtered by on-chain contribution history.
• Objective Metrics: Funding decisions leverage verifiable work (Git commits, prior grant success).
• Retroactive Funding: Communities fund proven outcomes, not promises, using frameworks like Ethereum's PGF.

Submitting and voting on proposals via mainnet L1s is prohibitively expensive and slow, creating a high barrier to participation. This limits proposal volume and voter turnout, centralizing decision-making.

• Gas costs for a single vote can exceed $50+ on Ethereum mainnet.
• Voting periods are artificially extended to 5-7 days to accommodate slow finality.
• Low throughput of ~15 TPS on Ethereum cannot scale for thousands of concurrent proposals.

Migrate proposal submission and voting to a dedicated, high-throughput L2 like Arbitrum or Optimism. This decouples governance speed from L1 congestion, enabling faster, cheaper cycles.

• Reduce voting gas costs by >90% to under $0.50.
• Finalize votes in hours, not days, using L2's ~1-3 second block times.
• Batch-settle results to L1 for ultimate security via optimistic or ZK-proof bridges.

Low-cost submission opens the door to spam and Sybil attacks, where malicious actors flood the system with low-quality proposals or manipulate votes. Current 1-token-1-vote models are vulnerable.

• Spam proposals waste community review time and DAO treasury funds.
• Sybil resistance is weak without expensive Proof-of-Personhood or delegation layers.
• Reputation systems like SourceCred are often off-chain and lack enforcement.

Implement a bonding curve for proposal submission (e.g., Aave's Temperature Check) and an on-chain reputation score based on past proposal success and peer review. This creates economic and social filters.

• Require a scalable bond (e.g., 100 DAI on Polygon) that is slashed for spam.
• Weight votes using a conviction voting model or wrapped reputation tokens.
• Leverage zero-knowledge proofs (e.g., zkSNARKs) for private, sybil-resistant credential verification.

Multi-chain treasuries (ETH on L1, USDC on Arbitrum, staked assets on Lido) create fragmented, opaque financials. Tracking grant disbursements and treasury health across chains is a manual accounting nightmare.

• No unified view of cross-chain treasury assets and liabilities.
• Slow, manual disbursements require multiple bridge transactions.
• Lack of real-time analytics on grant impact and runway.

Deploy a cross-chain treasury management system using safe{Wallet} multi-sig on an L2 hub, with Chainlink CCIP or LayerZero for asset movement. Automate disbursements via Sablier or Superfluid streaming.

• Aggregate portfolio view via DefiLlama-style dashboards.
• Automate multi-chain payouts with a single governance vote.
• Stream funds to grantees to enable continuous accountability and real-time milestone tracking.