ViVault

ViVault: Overview ViVault is an automated cryptocurrency portfolio management platform that uses real-time volatility monitoring to intelligently rebalance user portfolios without manual intervention. Built on Base blockchain using Lit Protocol's Vincent framework, it solves the critical problem of maintaining optimal portfolio allocations during volatile market conditions. The Problem The October 2025 tariff crisis demonstrated a harsh reality: $19 billion was wiped out in crypto markets within 24 hours, and investors who couldn't rebalance quickly watched their portfolios become dangerously unbalanced. Manual portfolio management fails during crisis moments because: Markets move faster than humans can react (crashes happen at 2 AM) Every transaction requires manual approval, causing critical delays Emotional decisions (panic selling, FOMO) lead to poor outcomes 24/7 monitoring is impossible for individual investors The Solution ViVault provides three core innovations:

1. Individual Smart Contract Vaults Each user gets their own dedicated vault contract deployed on Base blockchain. Unlike shared pools, users maintain complete ownership and transparency - your vault, your assets, your rules. All transactions are publicly verifiable on BaseScan.
2. Volatility-Based Automation Instead of rebalancing on arbitrary schedules, ViVault monitors real-time market volatility using Pyth Network oracles. The system categorizes market conditions into three levels: Low volatility (15-25%): Normal crypto market activity Medium volatility (25-35%): Elevated movement requiring attention High volatility (35%+): Crisis conditions triggering immediate rebalancing When volatility exceeds configured thresholds, the system automatically rebalances - buying low during crashes and selling high during pumps.
3. Trust-Minimized Automation via Vincent Abilities Using Lit Protocol's Vincent framework, ViVault enables automated execution without sacrificing security. Users authorize specific "abilities" once: EVM Transaction Signer: Signs transactions automatically Uniswap Swap Ability: Executes token swaps for rebalancing ERC-20 Token Transfer: Manages token movements within the vault The system can ONLY perform authorized rebalancing actions - it cannot withdraw funds, change settings, or access other users' vaults. Real-World Impact During a crisis scenario like October 2025: 2:00 AM: Tariff news breaks, ETH starts crashing 2:05 AM: ETH down 15%, volatility hits 38% 2:08 AM: ViVault automatically rebalances, buying the dip 8:00 AM: ETH recovers 20%, portfolio protected While manual traders slept through the crisis and missed optimal entry points, ViVault detected the volatility spike and executed rebalances within minutes - no human intervention, no emotional decisions, just mathematical precision. Key Features Individual Ownership: Dedicated vault contract per user, zero counterparty risk Real-Time Volatility Monitoring: Pyth Network oracles provide professional-grade price data Intelligent Automation: Rebalances based on market conditions, not arbitrary schedules Trust-Minimized Security: Lit Protocol's decentralized delegation, not centralized key custody Complete Transparency: All operations on-chain and publicly auditable Crisis Protection: Built specifically for Black Swan events like October 2025 User Journey Authenticate via Vincent's native authentication Deploy your personal vault contract on Base Deposit WETH and USDC into your vault Configure target allocation and volatility thresholds Authorize Vincent abilities for automated execution Monitor through real-time dashboard while automation runs 24/7 Technology Foundation Blockchain: Base (Coinbase Layer 2) Automation: Lit Protocol + Vincent Framework Price Data: Pyth Network decentralized oracles Smart Contracts: Solidity (VaultFactory, UserVault, VolatilityIndex) Frontend: React + TypeScript + shadcn/ui Backend: Node.js + Express + Vincent SDK The Bottom Line ViVault is a robo-advisor for crypto portfolios that never sleeps, never panics, and whose every move is publicly auditable. It combines Vincent's composable abilities (transaction signing, Uniswap swaps, token transfers) with real-time volatility monitoring to create an automated portfolio manager that protects users during the moments that matter most - when markets crash at 2 AM and every second counts.

How It's Made: Core Technical Implementation Overview ViVault's architecture centers on three critical technical components: automated execution through Vincent abilities, continuous volatility monitoring and on-chain updates, and comprehensive event logging through Envio. Each component solves a specific challenge in creating a truly automated, transparent portfolio management system.

1. Automation Using Vincent and Its Abilities The Core Challenge Traditional DeFi requires manual transaction approval for every operation. Users must be present to review and sign each transaction. This makes true automation impossible - you can't wake up at 2 AM to approve a rebalancing transaction during a market crash. The Vincent Solution Lit Protocol's Vincent framework provides "abilities" - pre-built, audited modules that enable specific blockchain actions through delegated signing. ViVault uses three abilities in a coordinated flow: EVM Transaction Signer Purpose: Enables automated transaction signing without user presence How It Works: When a user sets up ViVault, they create a PKP (Programmable Key Pair) through Lit Protocol. This PKP is a special type of wallet controlled by code rather than a private key in someone's possession. The user then delegates signing authority to ViVault's backend for ONE specific action: rebalancing their vault. Security Model: The delegation is cryptographically scoped. The backend can sign transactions that: Target only the user's specific vault address Call only the rebalance function Cannot be redirected to other contracts Cannot access other users' vaults When volatility triggers a rebalance, the backend uses the EVM Transaction Signer to create a valid signature using the user's PKP. The Lit Protocol network validates the delegation before allowing the signature, ensuring the backend hasn't exceeded its authorized scope. Uniswap Swap Ability Purpose: Executes token swaps for portfolio rebalancing How It Works: Vincent's built-in Uniswap integration handles the complexity of decentralized exchange interactions. When ViVault needs to rebalance (e.g., sell USDC to buy WETH), the Uniswap Swap Ability: Calculates optimal routing between Uniswap V2 and V3 pools Determines slippage tolerance based on market conditions Checks price impact to prevent sandwich attacks Executes the swap with MEV protection Returns swapped tokens to the vault Key Benefits: Pre-audited code (Vincent's abilities undergo professional security reviews) Optimal routing logic (better prices than naive implementations) Built-in MEV protection (prevents value extraction by miners/validators) No custom DEX integration needed (saves weeks of development) ERC-20 Token Transfer Purpose: Manages token movements within the rebalancing workflow How It Works: Rebalancing requires moving tokens between the vault and Uniswap. The ERC-20 Token Transfer ability handles: Approving Uniswap router to spend vault's tokens Transferring tokens from vault to Uniswap for swapping Receiving swapped tokens back into the vault Revoking approvals after transaction completes Security Features: Authorization checks at each step Tokens can only move within the rebalancing context Complete audit trail of all movements Automatic approval revocation prevents future exploitation Coordinated Ability Execution The innovation lies in chaining these abilities together atomically: Rebalancing Flow: Trigger: Backend detects volatility exceeds user's threshold Calculate: Determine optimal swap amounts (how much WETH to sell for USDC, or vice versa) Authorize: EVM Transaction Signer creates cryptographic signature using user's PKP Approve: ERC-20 Token Transfer approves Uniswap to spend tokens Swap: Uniswap Swap Ability executes the trade Receive: ERC-20 Token Transfer receives swapped tokens back Finalize: Transaction confirms on-chain, portfolio rebalanced Atomic Execution: All steps happen in a single transaction. If any step fails (insufficient liquidity, slippage too high, etc.), the entire transaction reverts and the portfolio remains unchanged. This prevents partial executions that could leave the portfolio in an unintended state. Example Scenario: Why This Matters: This architecture enables true "set it and forget it" automation. Users configure their preferences once, authorize the abilities once, and the system operates indefinitely without further intervention. During the October 2025 crisis, this meant rebalancing executed at 2:08 AM while users slept - impossible with traditional manual approval systems.
2. Volatility Index Maintenance The Core Challenge Determining WHEN to rebalance is as important as HOW to rebalance. Random or time-based rebalancing (e.g., "every Monday") doesn't account for market conditions and can lead to poor execution - rebalancing during calm markets wastes gas, while missing volatile periods leaves portfolios unprotected. Real-Time Volatility Monitoring ViVault maintains a continuously updated volatility index that measures market conditions every 10 minutes. Data Collection Process Real-Time Prices: Every 10 minutes, the backend queries Pyth Network's Hermes API for current WETH and USDC prices. Pyth aggregates data from 95+ first-party sources (exchanges, market makers) and provides cryptographically signed price feeds. Why Pyth: Decentralized (no single point of manipulation) Fast (sub-second price updates) Verifiable (cryptographic proofs included) Reliable (institutional-grade infrastructure) Historical Analysis: The system fetches 12 weeks of historical price data from Pyth's Benchmarks API. This provides sufficient data points (84 daily samples) for statistically significant volatility calculations. Statistical Calculation Step 1: Calculate Returns For each consecutive price pair, calculate the logarithmic return: Logarithmic returns have properties that make them ideal for volatility analysis - they're symmetric (a 10% gain followed by a 10% loss returns to the original price) and additive across time periods. Step 2: Measure Deviation Calculate the standard deviation of these returns, which represents how much prices deviate from their average movement. Higher standard deviation = higher volatility. Step 3: Annualize Since calculations use weekly data, multiply by the square root of 52 (weeks per year) to get annualized volatility comparable across different time periods. Step 4: Convert to Basis Points Express as basis points (1 bps = 0.01%) for precision in smart contracts, avoiding floating-point arithmetic issues. Example Calculation: On-Chain Storage VolatilityIndex Smart Contract: The calculated volatility gets written to an on-chain contract that stores: Volatility measurement (basis points) Current price (from Pyth) Timestamp of calculation Confidence interval (data quality metric) Why Store On-Chain: Transparency: Anyone can verify volatility calculations Immutability: Historical record cannot be altered Composability: Other protocols can use ViVault's volatility data Trustlessness: Frontend reads directly from blockchain, not backend API Auditability: Complete history of volatility over time Update Transaction: Each 10-minute cycle, the backend submits a transaction to the VolatilityIndex contract: Bundled Price Update: The transaction includes Pyth's cryptographic price proof, which updates the oracle price in the same transaction. This bundles two operations (Pyth price update + ViVault volatility update) into one, saving gas and ensuring perfect synchronization. Threshold-Based Triggering Once volatility is calculated and stored on-chain, the automation controller checks user-configured thresholds: Low Volatility (15-25%): Normal market conditions. System monitors but doesn't trigger rebalancing unless portfolio has drifted significantly from target. Medium Volatility (25-35%): Elevated market movement. System prepares for potential rebalancing and tightens monitoring. High Volatility (35%+): Crisis conditions. Immediate rebalancing triggered to protect portfolio from severe price swings. Per-User Configuration: Each user sets their own volatility thresholds. Conservative users might set 20% (rebalance often, minimize drift), while aggressive users might set 40% (rebalance rarely, accept more drift). Continuous Operation 10-Minute Cycle: Fetch current prices from Pyth Hermes API Fetch 12 weeks historical data from Pyth Benchmarks API (cached when possible) Calculate volatility using statistical methodology Submit update transaction to VolatilityIndex contract Wait for on-chain confirmation Check all user vaults against their configured thresholds Trigger rebalancing for any vault exceeding thresholds Sleep until next cycle Reliability Mechanisms: Retry logic for failed API calls (exponential backoff) Transaction replacement if blockchain congestion causes delays Sentry error tracking for monitoring and alerts Health checks every minute to verify system operational Result: A continuously maintained, transparent, verifiable record of market volatility that drives intelligent rebalancing decisions. During the October 2025 crisis, this system detected the 38% volatility spike within 10 minutes of the tariff announcement, triggering immediate rebalancing that protected portfolios.
3. Envio Event Indexing for Vault Logs The Core Challenge Smart contracts emit events for every significant action (deposits, withdrawals, rebalancing, etc.), but these events are scattered across the blockchain and difficult to query efficiently. Users need a way to view their complete vault history - what happened, when, and why - without manually scanning thousands of blocks. The Envio Solution Envio is a blockchain indexing platform that listens to smart contract events in real-time, processes them, and stores them in a queryable database. ViVault uses Envio to maintain comprehensive logs for each individual user's vault. What Envio Does Event Listening: Envio monitors the Base blockchain for events emitted by ViVault contracts: VaultFactory Events: VaultDeployed(address user, address vaultAddress) - Tracks when new vaults are created UserVault Events: Deposit(address token, uint256 amount, uint256 timestamp) - Logs deposits Withdrawal(address token, uint256 amount, uint256 timestamp) - Logs withdrawals RebalanceExecuted(address tokenIn, address tokenOut, uint256 amountIn, uint256 amountOut, uint256 timestamp) - Records every rebalancing operation VolatilityIndex Events: VolatilityUpdated(bytes32 feedId, uint256 volatilityBps, uint256 timestamp) - Tracks market volatility changes Event Processing: When Envio detects an event, it: Decodes the event data from raw blockchain logs Extracts relevant information (addresses, amounts, timestamps) Associates the event with the specific user's vault Stores in structured database format Makes available through GraphQL API Per-User Vault Filtering The Key Feature: Envio indexes events per vault address, enabling efficient queries for individual users. Instead of fetching all ViVault events globally and filtering client-side, the frontend can query "show me all events for vault 0xABC..." and receive only that user's activity. Query Example: Response: Frontend Integration Dashboard Display: The frontend queries Envio's GraphQL API to display: Transaction History Table: Chronological list of all vault operations Token amounts with proper decimal formatting Links to BaseScan for on-chain verification Filters by event type (deposits, withdrawals, rebalances) Portfolio Performance: Historical portfolio composition over time Visualization of rebalancing frequency Correlation between volatility spikes and rebalancing actions Transparency Features: Complete audit trail of automated actions Proof that rebalancing occurred when volatility thresholds were exceeded Gas costs for each operation Swap prices and slippage for each rebalance Hosted on Envio Infrastructure: ViVault's Envio indexer runs on Envio's hosted infrastructure, which provides: Reliability: 99.9% uptime guarantee Automatic scaling during high event volume Redundant data storage Real-time event processing (typically 1-2 second delay from on-chain confirmation to indexed availability) Performance: GraphQL API with sub-100ms response times Efficient querying with indexed database fields Pagination support for large histories Caching layer for frequently accessed data Developer Experience: No infrastructure management required Automatic updates when new events are added to contracts Built-in monitoring and alerting GraphQL playground for testing queries Why This Matters for Transparency Problem Solved: Without Envio, users would need to: Manually scan blockchain for their vault's transactions Decode raw event logs (requires technical knowledge) Aggregate data across multiple transactions Calculate derived metrics (rebalancing frequency, performance, etc.) With Envio: Open ViVault dashboard See complete vault history instantly Every automated action is logged and verifiable One-click link to on-chain verification Trust Through Transparency: Users can verify that ViVault's automation did exactly what it claimed: Rebalancing only triggered when volatility exceeded configured thresholds Swap amounts matched calculated optimal allocations No unauthorized actions occurred Gas costs were reasonable Slippage was within acceptable bounds Example Use Case: User wakes up after the October 2025 crisis and checks their ViVault dashboard: The user can see exactly what happened, when, why, and verify it on-chain - complete transparency enabled by Envio's event indexing. Integration Summary How All Three Components Work Together Setup Phase: User authenticates via Vincent and deploys vault User configures thresholds and authorizes Vincent abilities Envio begins indexing the new vault's events Ongoing Operation: Volatility monitoring (every 10 minutes): Backend calculates and updates on-chain volatility Threshold checking: System compares volatility against user's configured thresholds Automated execution (when triggered): Vincent abilities execute rebalancing without user intervention Event logging: Envio indexes all actions for transparent audit trail User Monitoring: Dashboard displays real-time volatility (read from on-chain VolatilityIndex) Portfolio composition shows current allocation Transaction history (powered by Envio) shows complete vault activity Everything verifiable on-chain through BaseScan links The Result A fully automated, transparent, trust-minimized portfolio management system that: Never requires manual intervention (Vincent abilities enable automated execution) Responds to real market conditions (volatility index maintains up-to-date market metrics) Provides complete transparency (Envio indexes every action for user verification) Operates 24/7 (all three systems run continuously) Maintains security (delegated permissions, not full control) During crisis events like October 2025, these three components work in concert: volatility monitoring detects the spike, Vincent abilities execute the rebalancing, and Envio logs the entire sequence - all while the user sleeps, confident their portfolio is protected.