The problem EcoVault solves

The Core Problem

Public goods and sustainability projects face funding challenges:

• One-time donations don't provide sustainable, ongoing support
• Idle capital doesn't generate value while waiting to be allocated
• Manual processes limit scale and transparency
• Lack of on-chain transparency reduces trust and accountability
• Projects struggle to secure predictable, recurring funding

How EcoVault Solves It

EcoVault turns contributions into a sustainable, yield-generating funding mechanism. Instead of one-time donations, funds are deposited into DeFi vaults that generate yield, which is automatically routed to verified projects via Octant v2. This creates a self-sustaining funding loop that makes capital more efficient, funding more predictable, and the entire process transparent and verifiable on-chain.

---

Use Cases & How It Makes Tasks Easier/Safer

For DAOs & Treasuries

Deploy idle treasury funds into EcoVault's yield-generating vault instead of letting them sit idle. The generated yield is automatically donated to public goods projects, turning idle capital into ongoing impact.

Before: Idle treasury funds generate no value
After: Treasury funds generate yield that automatically funds public goods

For Sustainability Projects

Receive ongoing, yield-based funding proportional to verified impact scores, rather than one-time grants. This provides more predictable, scalable support.

Before: One-time donations, unpredictable funding
After: Continuous yield-based funding based on verified impact

For Contributors & Funders

Connect your wallet and contribute with confidence. Funds are deposited into an audited vault that generates yield, benefiting projects over time. All transactions are transparent and verifiable on-chain.

Before: Manual donations, limited transparency, funds immediately spent
After: Automated yield generation, full on-chain transparency, sustainable impact

For the Public Goods Ecosystem

EcoVault productizes public goods funding: contributions → treasury → yield generation → automated allocation → projects. This automated, transparent flow reduces friction, increases trust, and enables scaling.

Before: Manual, opaque, one-time funding processes
After: Automated, transparent, continuous funding mechanism

For Transparency & Auditability

All yield generation and fund routing is on-chain. Anyone can verify:

• How much yield was generated
• Which projects received funding
• The impact metrics used for allocation
• Historical distribution data

This makes the mechanism safer, more accountable, and more attractive for institutional adoption.

---

How It Improves Existing Task Flows

---

Key Improvements

1. Capital efficiency: Idle funds generate yield instead of sitting unused
2. Automation: Smart contracts replace manual allocation processes
3. Transparency: All operations are on-chain and verifiable
4. Sustainability: Continuous yield funding replaces one-time donations
5. Trust: Audited smart contracts and on-chain verification increase accountability
6. Scalability: Programmable allocation based on impact scores enables data-driven scaling

---

In Summary: EcoVault transforms public goods funding from a manual, one-time process into an automated, sustainable, transparent mechanism that generates ongoing value for projects while providing full accountability and trust through blockchain technology.

Challenges I ran into

Challenges Encountered

1. ERC-4626 Vault Integration

Problem: ERC-4626 vaults require ERC20 tokens (WETH), not native ETH. Testnet vs mainnet differences.

Solution: Created SimpleERC4626Vault for testnet, added conditional logic for native ETH/ERC20 paths, documented WETH wrapping for mainnet.

2. Private Key Environment Variable Parsing

Problem: Inconsistent private key formats in environment variables (with/without prefixes).

Solution: Added parsing logic to strip prefixes and ensure proper 0x formatting before passing to ethers.js.

3. Network Switching & RPC Reliability

Problem: Users on wrong networks, single RPC endpoint failures.

Solution: Implemented automatic network detection/switching, added fallback RPC endpoints, and user-friendly error messages with manual network addition instructions.

4. Transaction Confirmation Timeouts

Problem: Long confirmation times on testnet, silent failures, no user feedback.

Solution: Implemented polling with retry logic, 2-minute timeout, loading states, and clear error messages.

5. Octant V2 Integration

Problem: Understanding Octant V2 allocation mechanism, handling native ETH vs ERC20 tokens.

Solution: Created SimpleOctantV2Allocator for testnet, implemented conditional logic for different token types, documented mainnet patterns.

6. Contract Deployment Complexity

Problem: Multiple interdependent contracts requiring specific deployment order and authorization setup.

Solution: Created automated deployment script that handles sequencing, authorization, and validation checks.

7. On-Chain/Off-Chain Data Sync

Problem: Keeping MongoDB in sync with blockchain state, race conditions.

Solution: Implemented event listeners, atomic API updates, validation checks, and retry logic.

8. BigInt Type Conversions

Problem: JavaScript number precision limits with large Solidity uint256 values.

Solution: Used TypeScript bigint types, conversion utilities for display, string representations in API responses.

---

Key Takeaway: Most challenges came from Web3 integration complexity, testnet vs mainnet differences, and ensuring robust error handling. The solution was iterative debugging, comprehensive error handling, and clear documentation for future development.