EcoVault
Grow ecosystems, not just profits.
About
The problem it 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 | Before | After | |--------|-------| | One-time donations | Continuous yield-driven funding | | Manual allocation processes | Automated smart-contract routing | | Idle capital sitting unused | Capital earning yield in DeFi vaults | | Opaque spreadsheets and off-chain tracking | On-chain, verifiable mechanics | | Fixed allocation amounts | Programmable, impact-based allocation | | Limited scalability | Data-driven, configurable scaling | --- ## 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.
How it's made
Challenges we 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.