Nakal

Overview

This project builds an ASI-sponsored AI copy trader that lets users copy trades of any public on-chain wallet with agentic intelligence and seamless execution. The system starts from the ASI One chat protocol, and all agents are registered and accessible via Agentverse.

How It Works

1. Start in ASI One Chat: User interacts with the system through the ASI One protocol.
2. Input Wallet: User pastes a public wallet address.
3. Data Fetch: Wallet history & PnL fetched via 1inch Portfolio & PnL APIs.
4. Agent Analysis (accessible via Agentverse):
   • Meme-Coin Agent: Suggests high-risk/high-reward plays.
   • Blue-Chip Agent: Focuses on safer, large-cap tokens.
   • Consensus Agent: Ranks suggestions & explains rationale.
5. User Decision: User selects tokens, sets USD amount.
6. Execution:
   • 1inch APIs: Provide quotes, optimal swap routes, and execute trades on-chain.
   • Polygon x402: Handles agentic payments—funds flow securely between users and agents, or between agents, to complete swaps and deposit results into user wallets.

Key Features

• Agentic Analysis: Multiple specialized AI agents debate & rank trade ideas, all accessible through Agentverse.
• Cross-Chain Ready: Supports swaps on Polygon with seamless fund routing.
• Non-Custodial Option: Users can sign transactions directly for safety.
• Full Transparency: Audit logs, risk scores, and transaction receipts.

Tech Stack

• Frontend: ASI One LLM (via Agentverse), integrating multiple agents for dynamic reasoning and trade suggestions.
• Backend: Python & Node.js for orchestration, 1inch APIs for trade data & swap generation, Polygon x402 for agentic payment execution.

Why We Chose These

• ASI: Powers agentic reasoning; all agents are registered on Agentverse and can analyze wallet data, debate strategies, and provide actionable suggestions.
• 1inch APIs: Reliable and efficient on-chain trade execution, quotes, and portfolio/PnL data.
• Polygon x402: Provides a secure, fast, and low-fee agentic payment layer for human-to-agent and agent-to-agent fund flows.

User Flow

1. Start in ASI One Chat → Paste wallet → Analyze → Get suggestions → Pick trade → Execute via 1inch + Polygon x402 → Funds in wallet.

How It's Made

This project combines multi-agent reasoning, on-chain data fetching, and automated trade execution into a seamless workflow.

Technical Architecture

1. Frontend & Agent Interaction

   • ASI One LLM serves as the entry point; all agents are accessible via Agentverse.
   • Agents communicate through structured JSON messages that encode trade suggestions, risk scores, and reasoning steps.

2. Agents & Orchestration

   • Wallet-Ingest Agent: Uses 1inch Portfolio & PnL APIs to fetch historical trades, normalizes timestamps, token decimals, and computes derived metrics (ROI, average holding, slippage).
   • Meme-Coin & Blue-Chip Agents: Implement custom scoring heuristics for volatility, liquidity, and market cap; outputs ranked suggestions with rationale.
   • Consensus Agent: Aggregates suggestions using weighted scoring based on risk and historical accuracy.
   • Execution Agent: Converts suggestions into 1inch calldata, verifies balances and allowances, and prepares transactions for Polygon x402 routing.

3. Backend

   • Python handles agent orchestration, data normalization, risk scoring, and LLM input/output preprocessing.
   • Node.js manages real-time websocket communication, 1inch API calls, and Polygon x402 integration for automated settlement.

4. Automated Execution & Payments

   • 1inch: On-chain swap execution, optimal route selection, and price checks.
   • Polygon x402: Handles agentic payments; ensures funds flow between users and agents or between agents, managing approvals and settlements automatically.

Notable Technical Aspects / Hacks

• Dynamic Agent Chaining: Agents can call each other’s outputs in real-time to refine suggestions—enables “debate-style” reasoning.
• Calldata Auto-Generation: Execution agent generates swap calldata programmatically based on LLM output without manual intervention.
• Risk-aware Execution: Pre-execution sanity checks include liquidity thresholds, slippage limits, and multi-agent confidence scores.
• Hybrid Tech Stack: Python for AI/data-heavy tasks, Node.js for real-time orchestration, all integrated seamlessly via APIs and WebSockets.
• Embedded Audit Trail: Every agent suggestion and executed swap is logged with timestamp, wallet, calldata, and transaction hash for full traceability.

This design enables a real-time, agent-driven trading assistant that bridges AI reasoning and on-chain execution while maintaining flexibility, safety, and transparency.