DelegateX

DelegateX is a non-custodial delegated trading platform that enables users to grant limited trading authority to skilled managers via ERC-20 approvals while the assets remain securely in the user's wallet. All trade executions and performance metrics are recorded immutably on the Ethereum blockchain, ensuring unprecedented transparency and trust.

Technical Foundation and Development Environment DelegateX relies on a secure and transparent architecture built using industry-standard development tools.

Hardhat for Smart Contract Development and Testing Hardhat is the core development environment used for building, testing, and debugging the DelegateX smart contracts (PerformanceTracker.sol, TradeLogger.sol, and the core delegation logic).

• Local Development: Hardhat provides a local Ethereum network (Hardhat Network) for rapid iteration. Developers can deploy, interact with, and test smart contracts without incurring real gas costs or delays associated with public testnets.

• Comprehensive Testing: The platform leverages Hardhat's testing capabilities (using tools like Mocha and Chai) to write unit and integration tests for all critical smart contract logic, particularly the non-custodial delegation flows (ERC-20 approve/transferFrom) and the on-chain P&L calculation logic. This is essential for ensuring security and correctness before deployment to the mainnet.

• Debugging: Hardhat provides detailed error messages and Solidity stack traces, making it easier to pinpoint and fix bugs in complex smart contract interactions.

Non-Custodial Delegation Mechanism The core innovation is the use of the ERC-20 approve() function:

• Client Action: The portfolio owner (client) calls approve() on their asset token (e.g., PyUSD) contract, specifying the manager's wallet address and a maximum spending limit.

• Manager Authority: The manager can then execute trades by calling transferFrom() on the token contract to move funds from the client's wallet directly to a trading smart contract or brokerage integration address, but only up to the approved limit.

• Asset Security: This mechanism ensures the manager never holds custody of the client's assets, maintaining the platform's non-custodial guarantee.

PayPal USD (PyUSD) Integration for Compliance and Payments The integration of PayPal USD (PyUSD), a US dollar-pegged stablecoin, is a strategic move to bridge traditional finance with the decentralized ecosystem and establish robust compliance and payment rails.

Enhanced Security and KYC Compliance

• Regulated Stablecoin: PyUSD is issued by Paxos Trust Company and is subject to US regulatory oversight, including Know Your Customer (KYC) and Anti-Money Laundering (AML) requirements.

• Institutional Bridge: For the DelegateX platform, PyUSD integration provides a layer of institutional-grade security and compliance. It allows the platform to offer features that align with traditional finance requirements:

  • Automated Reconciliation: Seamless bridging and automated reconciliation with PayPal's infrastructure simplify compliance reporting and audit trails for larger, regulated entities.

  • Enhanced Security Features: PyUSD's compliance framework enables DelegateX to support advanced features like multi-signature approvals for large delegation amounts, which is crucial for institutional clients.

Seamless Payment and Liquidity Integration

• Instant Fiat Liquidity: By leveraging PayPal's vast network, PyUSD enables instant fiat conversion for users who need to off-ramp funds quickly or for manager fee settlements, significantly reducing friction compared to traditional crypto-to-fiat processes.

• Stable Delegation Limits: Using a stablecoin like PyUSD ensures that the delegation limits set by the client are denominated in a predictable $1.00 value, simplifying risk management for both the client and the manager.

• Cross-Border Transactions: PyUSD facilitates efficient, cost-effective cross-border money movement for both client deposits/withdrawals and the remittance of performance fees to global managers.

The DelegateX project is developed using a modern, full-stack approach that prioritizes speed, type safety, and decentralized transparency. The core of the development process revolves around a separation between the user interface (Frontend), data persistence (Backend/Database), and the trustless logic layer (Blockchain). Frontend Development The client-facing application (the portfolio dashboard, delegation setup, etc.) is built for speed and robustness: | Technology | Role in Development | |---|---| | React 18 with TypeScript | Provides a modern, component-based UI architecture. TypeScript ensures type safety across the codebase, catching errors early and improving code quality and maintainability. | | Vite | Used as the build tool and development server, enabling lightning-fast development reload times and optimized production builds. | | Tailwind CSS & shadcn/ui | Tailwind provides a utility-first framework for rapid, custom styling. shadcn/ui offers a collection of pre-built, accessible UI components built on top of Tailwind, accelerating the creation of a professional interface. | | React Query & Recharts | React Query manages server-side state (fetching data from Supabase/MongoDB and the blockchain) efficiently. Recharts is specifically used to visualize the on-chain performance metrics and P&L data for the public dashboards. | | React Router | Handles client-side routing, enabling smooth, single-page application navigation between different portfolio views and delegation settings. | Backend & Database The platform uses a flexible and scalable architecture to handle user accounts and auxiliary trading data:

• Supabase: Serves as the primary solution, handling user authentication (login/signup) and providing a real-time database for storing off-chain data like user preferences, manager profiles, and initial mock trading events.
• MongoDB: Provides an alternative, flexible NoSQL database option for scalability and handling complex, non-relational data structures like calculated metrics or extensive trade history archives.
• React Query: Also utilized here to manage and synchronize the state of the data fetched from the backend and blockchain APIs with the React frontend. Blockchain Core (The Trust Layer) This is the most critical part of the stack, responsible for the non-custodial delegation and immutable record-keeping:
• Solidity 0.8.4: The programming language used to write the core smart contracts, including PerformanceTracker.sol and TradeLogger.sol, which enforce the delegation rules and record transactions on Ethereum.
• Hardhat: The main development environment for smart contracts. It provides a local Ethereum network, enabling developers to compile, deploy, and thoroughly test the Solidity code locally before mainnet deployment.
• Ethers.js: A JavaScript library that acts as the bridge between the frontend/backend and the Ethereum blockchain. It is used to interact with the deployed smart contracts, sending transactions (like delegating authority) and reading on-chain data (like verifying a portfolio's P&L). Development Tooling A robust set of tools is used to enforce quality and consistency across the codebase:
• TypeScript: Used universally (frontend, backend scripts, and even in conjunction with Hardhat testing) to ensure strong typing and prevent run-time errors.
• ESLint: Enforces strict code quality rules and style consistency across all JavaScript/TypeScript files, ensuring the codebase remains clean and maintainable.
• PostCSS and Autoprefixer: Used to process CSS (specifically Tailwind), automatically adding vendor prefixes to styles, ensuring broad cross-browser compatibility.