Trade

MAGIC-FI offers a comprehensive trading platform with support for spot, perpetual futures, and options across multiple asset classes.

Trading Features

Order Types

Trading Interface

Our trading interface provides professional-grade tools for both retail and institutional traders:

• Real-time order book with market depth visualization
• Advanced charting with 100+ technical indicators
• One-click trading and position management
• Portfolio analytics and P&L tracking
• API access for algorithmic trading

// Example: Place a limit order
const order = await client.placeOrder({
  symbol: 'BTC-PERP',
  side: 'buy',
  type: 'limit',
  quantity: 1.0,
  price: 45000,
  timeInForce: 'GTC'
});

console.log('Order placed:', order.id);

Vaults

MAGIC-FI Vaults provide automated yield optimization strategies managed by experienced professionals and algorithmic systems.

Vault Categories

Popular Vault Strategies

How Vaults Work

MAGIC-FI Vaults operate through a sophisticated architecture:

1. Deposit: Users deposit assets into selected vaults
2. Strategy Execution: Vault managers deploy capital across various DeFi protocols
3. Yield Generation: Strategies generate returns through trading, lending, staking, and arbitrage
4. Compounding: Profits are automatically reinvested to maximize compound returns
5. Withdrawal: Users can withdraw funds with minimal delay

Portfolio

The MAGIC-FI portfolio dashboard provides comprehensive analytics and management tools for tracking your investments across all platform features.

Portfolio Features

Portfolio Metrics

Staking

Earn passive income by staking your assets on MAGIC-FI. Our staking platform supports multiple assets with competitive rewards and flexible terms.

Staking Options

Staking Tiers

Quick Start Guide

Get started with MAGIC-FI in just a few minutes. Follow this step-by-step guide to begin trading and earning.

Getting Started

Prerequisites

• Web3 wallet (MetaMask recommended)
• Some ETH for gas fees
• Supported assets (USDC, USDT, ETH, BTC, etc.)

First Deposit

// Connect wallet and deposit
const wallet = await client.connectWallet();
const deposit = await client.deposit({
  asset: 'USDC',
  amount: 1000
});

console.log('Deposit successful:', deposit.txHash);

Referrals

Earn rewards by referring new users to MAGIC-FI. Our referral program offers competitive commission rates and bonus incentives.

Referral Tiers

How It Works

Leaderboard

Compete with top traders and earn recognition for your performance. Our leaderboard system tracks various metrics and offers exclusive rewards for top performers.

Leaderboard Categories

Current Top Traders

Platform Statistics

Real-time metrics and analytics for the MAGIC-FI ecosystem. Track platform growth, trading activity, and network health.

Key Platform Metrics

Trading Statistics

Points System

Earn MAGIC Points through various platform activities and redeem them for exclusive rewards and benefits.

How to Earn Points

Points Redemption

Python SDK

The MAGIC-FI Python SDK provides a powerful and easy-to-use interface for algorithmic trading, portfolio management, and data analysis.

Installation

# Install via pip
pip install magic-fi-sdk

# Install from source
git clone https://github.com/magic-fi/python-sdk.git
cd python-sdk
pip install -e .

Quick Start

from magic_fi import MagicFIClient

# Initialize client
client = MagicFIClient(
    api_key="your-api-key",
    secret="your-secret",
    testnet=False
)

# Get account info
account = client.get_account()
print(f"Account balance: {account.balance}")

# Place a limit order
order = client.place_order(
    symbol="BTC-PERP",
    side="buy",
    type="limit",
    quantity=0.1,
    price=45000
)
print(f"Order placed: {order.id}")

Core Classes

WebSocket API

Real-time data streaming for market data, account updates, and trading events through WebSocket connections.

Connection

# WebSocket endpoint
wss://api.magic-fi.com/ws

# Authentication required for private channels
{
  "method": "auth",
  "params": {
    "apiKey": "your-api-key",
    "signature": "signed-message",
    "timestamp": 1640995200000
  }
}

Public Channels

JavaScript Example

const ws = new WebSocket('wss://api.magic-fi.com/ws');

ws.onopen = function() {
    // Subscribe to BTC-PERP order book
    ws.send(JSON.stringify({
        method: 'subscribe',
        params: ['orderbook.BTC-PERP']
    }));
};

ws.onmessage = function(event) {
    const data = JSON.parse(event.data);
    
    if (data.channel === 'orderbook.BTC-PERP') {
        console.log('Order book update:', data.data);
    }
};

Code Examples

Practical code examples for common trading scenarios and platform integrations.

Market Making Bot

import asyncio
from magic_fi import MagicFIClient, WebSocketClient

class MarketMaker:
    def __init__(self, api_key, secret):
        self.client = MagicFIClient(api_key, secret)
        self.ws = WebSocketClient(api_key, secret)
        self.spread = 0.001  # 0.1% spread
        
    async def run(self, symbol):
        # Subscribe to order book updates
        await self.ws.subscribe(f'orderbook.{symbol}', self.on_orderbook)
        
    async def on_orderbook(self, data):
        symbol = data['symbol']
        mid_price = (float(data['bids'][0][0]) + float(data['asks'][0][0])) / 2
        
        # Calculate bid/ask prices
        bid_price = mid_price * (1 - self.spread)
        ask_price = mid_price * (1 + self.spread)
        
        # Cancel existing orders
        await self.client.cancel_all_orders(symbol)
        
        # Place new orders
        await self.client.place_order(
            symbol=symbol,
            side='buy',
            type='limit',
            quantity=1.0,
            price=bid_price
        )

# Run the market maker
maker = MarketMaker('your-api-key', 'your-secret')
asyncio.run(maker.run('BTC-PERP'))

Portfolio Rebalancing

class PortfolioRebalancer:
    def __init__(self, client, target_weights):
        self.client = client
        self.target_weights = target_weights  # {'BTC-PERP': 0.6, 'ETH-PERP': 0.4}
        
    def rebalance(self):
        account = self.client.get_account()
        total_value = account['total_value']
        
        positions = self.client.get_positions()
        current_weights = {}
        
        # Calculate current weights
        for position in positions:
            symbol = position['symbol']
            value = position['notional_value']
            current_weights[symbol] = value / total_value
            
        # Calculate required trades
        for symbol, target_weight in self.target_weights.items():
            current_weight = current_weights.get(symbol, 0)
            weight_diff = target_weight - current_weight
            
            if abs(weight_diff) > 0.01:  # 1% threshold
                trade_value = total_value * weight_diff
                current_price = self.client.get_ticker(symbol)['price']
                quantity = trade_value / current_price
                
                side = 'buy' if quantity > 0 else 'sell'
                
                self.client.place_order(
                    symbol=symbol,
                    side=side,
                    type='market',
                    quantity=abs(quantity)
                )

# Rebalance portfolio
rebalancer = PortfolioRebalancer(client, {
    'BTC-PERP': 0.6,
    'ETH-PERP': 0.3,
    'SOL-PERP': 0.1
})

rebalancer.rebalance()

Risk Disclosure

Market Risks

Risk Management Recommendations

1. Start Small: Begin with small position sizes
2. Use Stop Losses: Set automatic stop-loss orders
3. Diversify: Don't put all funds in a single position
4. Monitor Positions: Regularly check account balance
5. Understand Leverage: Only use leverage you understand

Bug Bounty Program

MAGIC-FI offers one of the industry's most comprehensive bug bounty programs to ensure platform security.

Reward Tiers

In-Scope Vulnerabilities

• Authentication & Authorization: Bypass mechanisms, privilege escalation
• Injection Attacks: SQL, NoSQL, command injection, XXE
• Business Logic Flaws: Trading logic, vault calculations
• Cryptographic Issues: Weak implementations, key management
• Smart Contract Bugs: Reentrancy, overflow, logic errors

Security Audits

MAGIC-FI undergoes regular security audits by leading blockchain security firms to ensure the highest standards.

Completed Audits

Audit Summary

Brand Assets

Download official MAGIC-FI brand assets for use in presentations, integrations, and marketing materials.

Logo Variations

Color Palette

Connect Wallet

Connect your Web3 wallet to start trading on MAGIC-FI. We support multiple wallet types for maximum flexibility.

Supported Wallets

Connection Steps

1. Click "Connect Wallet" button
2. Select your preferred wallet
3. Authorize the connection in your wallet
4. Switch to MAGIC-FI network if prompted
5. Start trading!

Network Configuration

Your First Trade

Learn how to place your first trade on MAGIC-FI with this step-by-step guide.

Before You Start

• Connect your wallet
• Deposit funds (USDC recommended for beginners)
• Understand the trading interface
• Set your risk management preferences

Step-by-Step Guide

Trading Tips for Beginners

• Always use stop-loss orders
• Don't risk more than you can afford to lose
• Monitor your positions regularly
• Understand funding rates for perpetual futures
• Practice with small amounts first

Mobile App

Trade on-the-go with the MAGIC-FI mobile app. Available for iOS and Android with full trading capabilities.

App Features

Download Links

Mobile-Specific Features

• Biometric Authentication: Face ID and fingerprint login
• Offline Mode: View portfolio when offline
• Quick Actions: Swipe gestures for fast trading
• Voice Commands: "Hey MAGIC-FI, buy 1 BTC"
• Dark/Light Mode: Automatic theme switching

MagicCore Overview

MagicCore is the high-performance blockchain layer powering MAGIC-FI's trading infrastructure. Built for speed, security, and scalability.

Core Architecture

Technical Specifications

Bridge

Seamlessly transfer assets between MAGIC-FI and other blockchains using our secure, fast bridge infrastructure.

Supported Networks

Bridge Process

1. Select source and destination networks
2. Choose asset and amount to bridge
3. Confirm transaction on source network
4. Wait for confirmations (5-15 minutes)
5. Receive assets on MAGIC-FI network

Bridge Fees

Clearinghouse

The MAGIC-FI Clearinghouse manages all trade settlement, margin calculations, and risk management across the platform.

Core Functions

Settlement Process

1. Order matching in the order book
2. Trade execution and price discovery
3. Clearinghouse validates trade details
4. Margin requirements calculated
5. Positions updated in real-time
6. Settlement completed instantly

Risk Management Features

• Position Limits: Maximum position sizes per market
• Margin Requirements: Dynamic margin based on volatility
• Auto-Liquidation: Automatic position closure at risk levels
• Circuit Breakers: Trading halts during extreme volatility
• Insurance Fund: Protection against negative balances

Oracle

MAGIC-FI's Oracle system provides accurate, tamper-resistant price feeds for all trading pairs and risk calculations.

Oracle Network

Price Feeds

Oracle Security

• Multi-Source Aggregation: Data from multiple exchanges
• Outlier Detection: Automatic filtering of anomalous prices
• Time-Weighted Average: TWAP pricing for stability
• Circuit Breakers: Halt trading on extreme price moves
• Cryptographic Proofs: All price data cryptographically signed

Order Book

MAGIC-FI's high-performance order book engine handles millions of orders with sub-millisecond matching.

Engine Specifications

Order Matching

Market Data

• Level 2 Data: Full order book depth
• Trade History: All executed trades
• Market Statistics: 24h volume, high/low, change
• Real-time Updates: WebSocket feeds
• Historical Data: OHLCV candles, trade data

MagicEVM Overview

MagicEVM is our Ethereum-compatible smart contract execution environment, enabling developers to build custom DeFi applications.

EVM Compatibility

Key Features

• EVM Opcodes: Full support for Ethereum opcodes
• JSON-RPC API: Compatible with Ethereum JSON-RPC
• Web3.js/Ethers.js: Use standard JavaScript libraries
• MetaMask Integration: Connect with popular wallets
• Block Explorer: View transactions and contracts

Performance Comparison

Tools for Builders

Comprehensive development tools and resources for building on MAGIC-FI's MagicEVM platform.

Development Stack

Getting Started

# Install MAGIC-FI CLI
npm install -g @magic-fi/cli

# Create new project
magic-fi init my-dapp

# Deploy to testnet
magic-fi deploy --network testnet

Available Tools

• Hardhat Plugin: Deploy and test on MagicEVM
• Truffle Support: Use Truffle for development
• Remix IDE: Browser-based development
• Faucet: Get testnet tokens for development
• Templates: Starter templates for common DApps

Developer Resources

Native Transfers

Efficient native token transfers on MagicEVM with optimized gas usage and enhanced security features.

Transfer Features

Transfer Types

Code Examples

// Simple transfer
await magicToken.transfer(recipientAddress, amount);

// Batch transfer
await magicToken.batchTransfer([
    {to: addr1, amount: amount1},
    {to: addr2, amount: amount2}
]);

// Scheduled transfer
await magicToken.scheduleTransfer(
    recipientAddress, 
    amount, 
    futureTimestamp
);

System Contracts

Core system contracts that power MagicEVM functionality, including governance, staking, and protocol operations.

Core Contracts

Contract Addresses

Governance Features

• Proposal Creation: Submit protocol improvement proposals
• Voting Power: Vote based on MAGIC token holdings
• Execution: Automatic execution of approved proposals
• Timelock: Delays for security-critical changes
• Delegation: Delegate voting power to others

Perpetual Assets

Trade perpetual futures on major cryptocurrencies with up to 100x leverage. No expiration dates, 24/7 trading.

Available Perpetuals

Perpetual Features

How Perpetuals Work

1. Index Price: Based on spot prices from multiple exchanges
2. Mark Price: Fair price used for liquidations and unrealized P&L
3. Funding Payments: Periodic payments between long/short positions
4. Margin Requirements: Initial and maintenance margin levels
5. Liquidation: Positions closed when margin insufficient

Contract Specifications

Detailed specifications for all trading contracts including perpetuals, futures, and options.

Perpetual Contracts

Trading Hours

• Perpetuals: 24/7/365
• Spot: 24/7/365
• Options: 24/7 (except during settlement)
• Maintenance Windows: Sundays 02:00-03:00 UTC

Position Limits

Risk Parameters

• Circuit Breakers: Trading halted if price moves >20% in 5 minutes
• Position Limits: Maximum position sizes to prevent concentration risk
• Order Size Limits: Maximum single order sizes
• Rate Limits: Maximum 1000 orders per second per account

Margin Tiers

Dynamic margin requirements based on position size and market volatility to optimize capital efficiency.

BTC-PERP Margin Tiers

Margin Calculation

Dynamic Adjustments

• Volatility Adjustment: Margin rates increase during high volatility
• Liquidity Adjustment: Higher margins for less liquid assets
• Concentration Risk: Additional margin for large positions
• Cross-Margin: Use unrealized profits as collateral

Fees

Transparent fee structure with competitive rates for all trading activities on MAGIC-FI.

Trading Fees

VIP Fee Tiers

Other Fees

• Funding Fees: Variable, paid between long/short positions
• Bridge Fees: 0.05% - 0.15% depending on network
• Withdrawal Fees: Network gas fees only
• Vault Fees: 2% performance fee, 0.5% management fee
• API Usage: Free for all users

Fee Rebates

Order Types

Comprehensive order types for precise trade execution and risk management strategies.

Basic Order Types

Advanced Order Types

Time in Force Options

• GTC (Good Till Canceled): Order remains until filled or canceled
• IOC (Immediate or Cancel): Fill immediately, cancel remainder
• FOK (Fill or Kill): Fill completely or cancel entire order
• Day Order: Cancel at end of trading day
• GTD (Good Till Date): Cancel at specified date/time

Order Examples

// Limit order
{
  "symbol": "BTC-PERP",
  "side": "buy",
  "type": "limit",
  "quantity": 1.0,
  "price": 45000,
  "timeInForce": "GTC"
}

// Stop loss order
{
  "symbol": "BTC-PERP",
  "side": "sell",
  "type": "stop_market",
  "quantity": 1.0,
  "stopPrice": 44000,
  "timeInForce": "GTC"
}

Margining

Flexible margin system supporting both cross-margin and isolated margin modes for optimal risk management.

Margin Modes

Margin Components

Cross Margin Benefits

• Capital Efficiency: Use profits from one position to support others
• Auto Margin Transfer: Automatic rebalancing between positions
• Lower Liquidation Risk: Portfolio-level liquidation calculations
• Flexible Leverage: Adjust leverage dynamically

Isolated Margin Benefits

• Risk Isolation: Limit risk to allocated margin
• Position Control: Precise risk management per trade
• Strategy Separation: Keep different strategies separate
• Learning Tool: Better for beginners

Margin Calls and Liquidation

1. Margin Warning: Alert when margin ratio reaches 80%
2. Margin Call: Notification when ratio reaches 90%
3. Liquidation: Automatic position closure at 100%

Liquidations

Automated liquidation system to protect users and maintain platform stability during volatile market conditions.

Liquidation Process

Liquidation Triggers

Protection Mechanisms

Preventing Liquidation

• Monitor Margin Ratio: Keep track of your risk level
• Add Collateral: Deposit more funds when warned
• Reduce Position: Close part of your position
• Use Stop Losses: Set automatic exit points
• Lower Leverage: Use conservative leverage levels

Liquidation Fees

Funding

Periodic funding payments that keep perpetual contract prices aligned with underlying spot prices.

How Funding Works

Funding Rate Calculation

Funding Rate = (TWAP Premium + Clamp(Interest Rate - TWAP Premium, 0.05%, -0.05%))

Where:
- TWAP Premium = (Perpetual Price - Index Price) / Index Price
- Interest Rate = (Lending Rate - Borrowing Rate) / 3
- Clamp ensures rate stays within ±0.05% bounds

Current Funding Rates

Funding Payment Calculation

Funding History

Historical funding rates help traders understand long-term market sentiment and premium patterns.

Trading Strategies

• Funding Arbitrage: Profit from funding rate differences
• Position Timing: Open/close before funding to avoid payments
• Sentiment Analysis: High positive funding indicates bullish sentiment
• Mean Reversion: Extreme funding rates often revert to mean

Protocol Vaults

Core protocol vaults that power MAGIC-FI's automated trading and yield generation strategies.

Vault Categories

Vault Performance

Vault Mechanics

Risk Management

• Position Limits: Maximum exposure per market
• Volatility Controls: Reduce risk during high volatility
• Correlation Monitoring: Avoid over-concentration
• Stress Testing: Regular backtesting under extreme scenarios
• Emergency Stops: Automatic halt during anomalous conditions

Vault Leaders

Top-performing vault managers and strategies ranked by risk-adjusted returns and consistency.

Performance Ranking

Manager Categories

Performance Metrics

Becoming a Vault Leader

• Track Record: Minimum 6 months of verified performance
• AUM Threshold: Manage at least $1M in assets
• Risk Management: Demonstrate proper risk controls
• Transparency: Provide detailed strategy description
• Community Rating: Positive investor feedback

Vault Depositors

Information and tools for users investing in MAGIC-FI vaults, including deposit strategies and performance tracking.

Depositor Benefits

Top Depositor Allocations

Deposit Strategies

Depositor Tools

• Portfolio Tracker: Real-time P&L and allocation view
• Performance Analytics: Risk-adjusted return metrics
• Withdrawal Planner: Optimize withdrawal timing
• Tax Reporting: Detailed records for tax purposes
• Alerts: Notifications for performance milestones

Multi-sig

Multi-signature wallets and governance for enhanced security and decentralized control of protocol operations.

Multi-sig Implementation

Signer Composition

Governance Process

1. Proposal Creation: Community or team creates proposal
2. Discussion Period: 7-day community discussion
3. Voting Phase: Token holders vote on proposal
4. Multi-sig Execution: If passed, multi-sig executes changes
5. Timelock Delay: Critical changes have execution delay

Security Measures

• Hardware Security: All signers use hardware wallets
• Geographic Distribution: Signers spread across multiple time zones
• Identity Verification: All signers are known to the community
• Regular Rotation: Signer set updated periodically
• Emergency Procedures: Clear protocols for crisis situations

Recent Multi-sig Activity

API Documentation

Comprehensive REST API and WebSocket interfaces for algorithmic trading and application development on MAGIC-FI.

Authentication

All API requests require authentication using API keys:

import { MagicFIClient } from '@magic-fi/api';

const client = new MagicFIClient({
  apiKey: 'your-api-key',
  secret: 'your-secret',
  testnet: false // true for testnet
});

Core Endpoints

WebSocket Feeds

// Subscribe to real-time market data
const ws = client.websocket();

ws.subscribe('orderbook.BTC-PERP', (data) => {
  console.log('Order book update:', data);
});

ws.subscribe('trades.ETH-PERP', (data) => {
  console.log('New trade:', data);
});