VetoVault

VetoVault is a hybrid EVM/WASM execution sandbox on Arbitrum. It uses Arbitrum Stylus (Rust) as a math coprocessor to physically block AI agents from executing volatile trades — the first gas-efficient statistical guardrail for autonomous DeFi.

💡 The Problem

AI trading agents optimize for return, not safety. An agent will chase a 400% APY memecoin with the same conviction it uses for a 4% stablecoin yield. Current smart account architectures like ERC-4337 implement access control — who can call a function. But they don't implement execution physics — what constitutes a sane trade.

🛡️ The Solution: VetoVault

VetoVault solves this with a Hybrid EVM/WASM architecture deployed on Arbitrum Sepolia:

1. The Vault (Solidity): Custodies user funds and enforces access control. The vault owner sets a maximum acceptable volatility threshold in basis points.

2. The Risk Engine (Stylus/Rust): A WASM-compiled math coprocessor. When the AI agent submits a trade, it includes historical prices of the target asset as calldata. The Risk Engine iterates the array, computes statistical variance using pure U256 integer math, and returns the result.

3. The Guardrail: If variance exceeds the owner's threshold, the transaction reverts with a custom Rust error: VolatilityExceedsThreshold(computed, limit). No funds move.

⚡ Why Stylus?

Computing variance over a 50-element price array in standard Solidity costs ~142,160 gas. The same computation in Stylus (WASM) costs ~14,200 gas — 90% cheaper (~10× savings). Without Stylus, on-chain statistical finance is economically impossible. VetoVault proves that WASM unlocks an entire class of quantitative guardrails that EVM alone cannot support.

📦 Tech Stack

- Vault Contract: Solidity (EVM) — fund custody, 33 Foundry tests passing

- Risk Engine: Rust/Stylus (WASM) — compute_variance(), pure U256, no_std

- Trading Agent: Python (web3.py, CoinGecko API, intentionally aggressive)

- Dashboard: Next.js 16, React 19, Tailwind CSS v4 — cyberpunk SOC-style control panel

Day 1: Ideated and validated the EVM/WASM coprocessor pattern. Scaffolded the Rust Stylus contract (compute_variance), Solidity VetoVault, and cross-contract ABI interface. Wrote the first Foundry test.

Day 2: Completed all 33 Foundry tests. Built the Python AI agent with intentionally aggressive trade logic (targets volatile assets to prove the system). Wired up the CoinGecko price feed and uint256 array formatting. Deployed and verified both contracts on Arbitrum Sepolia.

Day 3: Built the Next.js cyberpunk dashboard with a live split-screen Human Control Panel + Agent Terminal, real-time trade log, price chart (Recharts), and the screen-shaking red intercept alert. Deployed to Railway (agent) and Vercel (dashboard). Ran end-to-end demo: volatile RUGCOIN blocked (2450 BPS variance > 1000 BPS threshold), stable ETH passes.

Key challenge: Stylus no_std environment requires manual U256 arithmetic without standard Rust integer overflow protection — solved with checked math and scaled integers to avoid precision loss.

Not currently raising. Open to Arbitrum ecosystem grants to continue developing VetoVault as an open primitive — the guardrail layer between retail capital and autonomous AI agents.