TradeAlgoAVS

TradeAlgoAVS Overview TradeAlgoAVS is a decentralized, non-custodial hedge fund platform that enables users to create, execute, and subscribe to trading strategies without relinquishing custody of their funds. To try something different, instead of focusing right away on the crypto markets, we decided to make TradeAlgoAVS agents trade stocks in the traditional market first! TradeAlgoAVS allows: Successful traders to scale their strategies into hedge fund-like structures without taking on the liabilities of managing client funds. Investors to allocate funds to self-curating, on-chain-verified trading strategies based on performance statistics. Coders and AI engineers to design and develop autonomous trading agents and earn commission. Supporters to stake on operators and participate in the network’s security and growth. Operators (built with Autonome’s Custom Template powered by AgentKit) execute strategies while ensuring security and trust-minimized execution using EigenLayer’s Actively Validated Services (AVS). This framework leverages EigenLayer restaking to provide trust-minimized, on-chain-verifiable trading execution. Key Features Decentralized & Non-Custodial Trading Strategies Users retain full control over their assets. Strategy providers monetize their algorithms without revealing their proprietary code. Execution is performed by off-chain Operators, including AI agents hosted on Autonome. Trust-Minimized Execution & On-Chain Verification Operators stake funds and are slashed for malicious behavior. Trading execution is validated using M-of-N statistical aggregation. Fraud-proof mechanisms detect deviations from expected performance benchmarks. The goal is to implement WYSIWYG literally what you see when you click subscribe in terms of strategy expected performance statistics should be what you get consistently in the long run. Self-Curating Autonomous Strategies Strategies are on-chain verified based on real-time performance statistics. Poor-performing strategies are naturally filtered out. Strategy providers must backtest and paper trade before publishing. Comparison: Traditional Hedge Funds vs. TradeAlgoAVS Feature Traditional Hedge Fund TradeAlgoAVS Custody of Funds Investors must transfer assets to fund managers. Investors retain full control of their assets. Strategy Transparency Black-box strategies, requiring blind trust. Strategies remain private but validated via statistical proofs. Execution Model Trades executed by centralized fund managers. Trades executed by decentralized Operators, including AI Agents. Fees & Access High fees, often requiring long lock-up periods. Competitive fees, full transparency, no lock-up periods. Investor Protection Requires trust in fund managers and regulators. On-chain verification ensures fair execution.

AVS Design Trust Model TradeAlgoAVS ensures Operators: Execute trades correctly according to strategy logic. Do not have custody of user funds. Maintain confidentiality of strategy logic. Distribute fees based on agreed subscription models. Slashing Conditions: Operators are slashed if they: Deviate significantly from expected strategy performance. Execute trades incorrectly or inefficiently. Engage in front-running or exploitative behavior. Task Design & Execution Model Each trading strategy execution is modeled as a Task in the AVS network. In the Trading Algo AVS or the Agentic Trading protocol, a task T(s,u,m) is defined as a triplet consisting of strategy S, investor I, and market M, where the market is defined as M(p,t) based on symbol pairs and time periods. The assumption is that good strategies remain consistent across honest and efficient executing operators, guaranteeing a set of consistent statistics when a task is performed. The statistics used to verify an operator's output include the task’s ROI, profitability, and risk. If all operators agree within a standard deviation, the aggregated result is sent on-chain. For simplicity (scoping down for the hackathon), the symbol pair can be predefined as part of the strategy, and the time period for each market can be set to one trading day. If an investor I_i​ subscribes to strategy S_i today, a task is generated for it tomorrow and continues daily until the investor unsubscribes. The simplified task T_i is (S_i,I_i). If there are n active subscriptions when the trading day starts, there should be n tasks. Additionally, the task processor can define mock tasks, which are handled as paper trading tasks rather than real trade executions. Task Workflow Strategy providers submit a strategy hash and execution rules. Subscribers choose strategies and agree to fees. AI Agent Operators fetch execution signals and trade on behalf of subscribers. Operators submit signed execution proofs on-chain. Validators verify execution and distribute fees accordingly. Operator Execution & Validation TradeAlgoAVS employs an M-of-N aggregation model where multiple Operators execute the same strategy, and performance statistics are compared to ensure consistency. Validation Metrics Include: Return on Investment (ROI) Profit percentage A measure of Risk/Drawbacks/Exposure If an Operator’s results deviate significantly from the quorum's statistical norm: They are flagged for fraud. They are slashed if malicious behavior is proven. Why This Approach Works ✅ Ensures Operators remain accountable for overall performance. ✅ Allows AI Agents to autonomously optimize execution while staying within acceptable performance bounds. ✅ Efficient and scalable compared to full trade-by-trade validation. Self-Curating Strategy Selection & Operator Reputation System Operator Incentives for Good Behavior Slashing Mechanisms Operators lose staked funds for malicious execution. Fraudulent executions result in disqualification. Reputation System High-reputation Operators get higher trade execution priority. Bad actors get blacklisted. How TradeAlgoAVS Filters Out Poor Strategies Operators Reject Poor-Performing Strategies Higher Fees for Riskier Strategies Reputation-Based Selection Ensures Only High-Quality Strategies Remain Smart Contract Implementation for Reputation & Strategy Selection Operators’ reputation scores are stored on-chain. Strategies have on-chain performance ratings, influencing Operator selection. Execution fees adjust dynamically based on risk. Reward & Penalty Economics TradeAlgoAVS’s incentive structure ensures anti-fragility and hacker-resistant operations. Strategy Providers must: Implement checks for open orders and account balances. Backtest and paper trade their strategies before listing them. Operators must: Collaborate to ensure consistent and reproducible results. Avoid race conditions that could cause discrepancies in execution statistics. Validation by Quorum ensures Operators only get rewarded if their results align with statistical expectations. Why EigenLayer? Security Leverages EigenLayer’s restaking model. Operators stake ETH, ensuring execution integrity. Efficiency M-of-N statistical aggregation reduces gas costs. Batch processing improves execution speed. Decentralization No single Operator controls execution. Multiple AI Agents verify execution. Confidentiality Users never see the strategy code. Strategy providers retain full intellectual property control.

Declarative Execution Model for Operators Listen for subscription creation, updates, and deletion events from the smart contract. Each strategy defines a trading period (e.g., one trading day). If an investor subscribes today, a task is generated for execution tomorrow. If there are n active subscriptions, n tasks are created. Each task is executed by one Operator. If multiple Operators execute the same task, quorum-based validation ensures only correctly executed results receive rewards. Operators only receive rewards if their results align with other quorum-executing Operators. If discrepancies occur, all involved Operators get slashed. System-wide Assumptions The same strategy should yield similar performance under the same market conditions. Task results are aggregated across strategies on the same day, allowing for quorum-based rewards and penalties.

Conclusion TradeAlgoAVS democratizes hedge fund execution while eliminating trust and custody risks. By combining decentralized AI-driven execution, EigenLayer-secured validation, and self-curating strategy selection, the system creates a trust-minimized, efficient, and scalable autonomous trading ecosystem.

For more details, visit the GitHub mono-repository: TradeAlgoAVS

We built this project as a decentralized trading automation system leveraging EigenLayer AVS, Nillion Secret Vault, and Autonome AI (Custom Template + AgentKit) as operators, with a frontend powered by Next.js and Coinbase OnchainKit. Here’s how everything comes together:

Frontend (DApp) - Next.js & Coinbase OnchainKit The frontend is built with Next.js and TypeScript, allowing investors to browse, subscribe to, and manage trading strategies. We integrated Coinbase OnchainKit to handle wallet authentication and transaction signing seamlessly, improving user onboarding. Wagmi + Ethers.js were used to interact with our smart contracts. TailwindCSS for styling, making UI iterations super fast.

Strategy & Credential Storage - Nillion Secret Vault Instead of storing sensitive information on-chain, we used Nillion Secret Vault to securely manage: ✅ Strategy Codes - The actual trading logic that operators execute. ✅ Investor Account Credentials - Required for placing trades on behalf of investors. The smart contract only stores a UUID, which references these encrypted documents in Nillion. This design keeps security tight while reducing on-chain complexity and costs. SV integration was hacky and we had to introduce an additional backend server we didn’t want to have since SV does not have more granular permission yet. We were not able to define roles to who can change schema vs write or read. Nor could we set read permission based on the account connected. There was another hack we had to do since SV had limited field types. Our strategy code was uploaded as files, which we had to convert to string if we want to use SV without using other storage to first store the file and only store URI in SV); however, we later found out when testing with real strategy python scripts that the string exceeded the allowed length. It was unclear how long the string could be so we tried chopping it into a bunch of strings of smaller sizes and stuffing them into an array. That worked.

Autonomous AI Operator - Langchain & Wealthsimple (Super Hacky 😅) We built an Autonome agent operator (using Custom Template) that can log into an investor’s Wealthsimple account, fetch data, and monitor activity via natural language commands, extending AgentKit’s capability to trade stocks. 💡 Why Wealthsimple? Zero Trading Fees – Ideal for high-frequency trading strategies. But… They Have No API or SDK 😭 The Wealthsimple Hack 🔥 This was by far the most painful part. Since Wealthsimple doesn't offer an API, we had to: 1️⃣ Scrape the Web UI – Simulating user actions via headless browsers. 2️⃣ Intercept cURL Commands – Extracting the raw HTTP requests behind each trade. 3️⃣ Bypass Annoying 2FA – We hacked a workaround (but it was messy). 🚨 Biggest Constraint: Traditional markets close overnight & on weekends (unlike crypto), so we couldn't test after hours! We considered: Simulations Paper trading Backtesting solutions But in the end, we prioritized learning new hackathon partner tech over fine-tuning our Wealthsimple integration.

AI Trading Assistant (Almost Built) - Telegram Bot We wanted investors to chat with their AI operator via Telegram to: 🤖 Monitor their portfolio 💬 Ask trading strategy questions 📊 Manually approve or modify trades But… we ran out of time before fully integrating it.

Backend & Smart Contracts - EigenLayer AVS & Performance Validation Our protocol is based on EigenLayer AVS, ensuring that: ✔️ Operators execute trades correctly ✔️ Investors get the performance they subscribed for We cloned Layr Labs’ Incredible Squaring AVS as a base, since it was the closest open-source model to our validation approach. Aggregated Performance-Based Validation – We validate operator performance based on statistical consistency instead of just signature verification. Quorum-Based Execution – Ensuring multiple operators agree on results before trades are executed. We debated: Zero-Knowledge Proofs vs Other Verification Methods Imperative vs Declarative Execution Models Various Security Assumptions In the end, we had to simplify the design due to time constraints.

What We Learned & Final Thoughts We spent a lot of time wearing different "hats"—pretending to be malicious actors trying to break the system and refining our security model. Unfortunately, we couldn’t get all components fully working together before the submission deadline 😅, but we had an absolute blast hacking through Web3, AI, and DeFAi automation as well as TraditionalFAI. 🚀