# Welcome to 0xLeverage Introduction to the 0xLeverage ecosystem
## Overview Welcome to 0xLeverage, the only leverage trading Telegram bot that lets you trade on any token that passes our security and whitelisting standards. We also offer **free spot trading** with 0% buy and sell fees, giving you a cost effective way to trade across supported chains without hidden charges. 0xLeverage is a one stop shop for Telegram DeFi trading, supporting EVM compatible chains such as Ethereum, Base, and BNB Chain, as well as Solana. Our Solana integration is a core part of the platform, allowing you to leverage trade almost any token in the Solana ecosystem that meets our requirements, including tokens launched on Pump.fun, Bonk, Raydium Launchpad, and other major launch platforms. The platform offers both regular spot trading bot services and leverage trading bot services. Currently, 0xLeverage is in its V1 public release, meaning anyone can access the leverage bot by sending a message to our official 0xLeverage Trading Bot. The only requirements are that you join both the official 0xLeverage Telegram chat and the official 0xLeverage Gains chat. We recommend reading this whitepaper in full, as it contains important details about 0xLeverage and its utilities. For those who prefer a quick start, follow these steps: 1\. Download and create a Telegram account. 2\. Send a direct message to the [0xLeverage Trading Bot](https://t.me/leveragetradebot) and click “Start” or type /start. 3\. Join the 0xLeverage main chat and the 0xLeverage Gains channel. 4\. Copy and paste a contract address into the chat with the bot. 5\. Follow the prompts from the bot to open or close your position. More details about step 5 can be found here. For any support questions, join and post them in our support group: Supported Chains\ \ Solana Ethereum Base BNB Chain
# 0xLeverage Links All 0xLeverage links can be found in our [Linktree](https://docs.0xleverage.io/) # What is a Trading Bot? Telegram Trading Bot Overview A Telegram trading bot is exactly what it sounds like. A specialized software program that works within the Telegram messaging application, enabling users to engage in various aspects of cryptocurrency trading and financial management directly through chat interfaces. These bots can offer a wide range of functionalities, including: * Trade Execution: Users can initiate buy and sell orders for cryptocurrencies, stocks, or other financial assets through simple commands within the Telegram chat. * Market Analysis: Some bots provide real-time market data, price charts, technical indicators, and other analytics to help users make informed trading decisions. * Portfolio Management: Users can track their portfolio's performance, view asset allocations, and receive alerts on significant market movements. * Risk Management: Bots may allow users to set stop-loss and take-profit orders to minimize losses and lock in profits automatically. * Leverage Trading: Advanced bots may support leverage trading, allowing users to magnify gains (or losses) by borrowing additional capital. * Notifications: Users can receive price alerts, news updates, and trading signals, ensuring they stay informed about market developments. * Automated Trading: Some bots offer algorithmic trading capabilities, where predefined strategies can be automated to execute trades on behalf of the user. * Security Features: To protect user accounts, many Telegram trading bots employ robust security measures, including two-factor authentication and encryption. Telegram trading bots provide a convenient and user-friendly interface for traders to interact with crypto markets, access crucial information, and execute trades, all from the comfort of their Telegram chat. # 0xLeverage Trading Bot Here's a straightforward breakdown of how the 0xLeverage Telegram Leverage Trading Bot operates
**Brief Overview:** * **1-7x Leverage (depending on initial position size)**: Users can now apply leverage ranging from 1x to 7x to their trades, allowing them to control positions significantly larger than their initial capital investment. This increased leverage potential can increase profits. * **Maximum total position of $5,000 USD (subject to change):** Our users can open any trades as long as the total position size does not exceed $5,000 USD, regardless of the amount borrowed or initial user amount. This ensures that users can not put themselves in over-exposed positions, securing both borrowed funds and user initials.
* **Position Sizes of $5-2000 USD (subject to change)**: We've tailored this feature to cater to traders with varying budgets and risk appetites. Users can engage with position sizes as low as $5, extending up to $2000, providing accessibility to a broader user base.
# Supported Networks Ethereum\ \ Solana — enjoy full leverage trading across tokens launched via Pump.fun, Bonk, Raydium Launchpad, and other major launch platforms Base BNB Chain\ \ Arbitrum # Additional Leverage Bot Utilities Additional Leverage Bot Utilities 1\. Add Margin for Enhanced Risk Management The add margin feature gives you more control over your position by adding extra funds, reducing the risk of liquidation. If margin is added too late and liquidation is already imminent, the bot may not have time to process it. Adding margin early, especially when your position is near the liquidation threshold, increases the chance of avoiding liquidation.
Example You start with $100 of your own funds and borrow $400, giving you a $500 position. The asset price is $1 and, with 5x leverage, your liquidation price is $0.86. This is based on a 70% leverage buffer divided by your leverage amount: 70% ÷ 5 = 14%, $1.00 – 14% = $0.86. If you add another $100 to make the position safer: • You now have $200 of your own money in the trade. • The position size remains $500 ($400 borrowed + $100 initial). • New leverage = $500 ÷ $200 = 2.5x leverage. • The buffer is 70% ÷ 2.5 = 28%. • New liquidation price = $1 × (1 – 0.28) = $0.72. 2\. Enhanced Stop Loss and Take Profit Management You can add, edit, or remove stop-loss and take-profit orders after opening a trade. They can be set from the open trade menu when tracking your position using the command /trackall or by clicking “check positions.” This flexibility lets you adjust your risk and profit targets as market conditions change. **Disclaimer** **Stop-loss and take-profit orders are not guaranteed and should only be used when you cannot monitor your trades. Due to volatility, we cannot guarantee that any stop-loss or take-profit will trigger accurately or effectively. 0xLeverage assumes no liability for the final PNL of any position closed with either a stop-loss or take-profit.** # Tutorials Bot Set-up + Trade Walkthrough - \ Bot Settings - \ Opening a Trade - \ Closing a Trade - \ How Does 0xLeverage Work - \ \ More coming soon!\
# 0xLeverage Referral System The 0xLeverage referral program stands out as the most lucrative in the trading bot space, offering higher referral earnings per trade than any other platform. Here’s why: 0xLeverage calculates fees based on the entire leveraged position, this includes both the user’s initial capital and the additional borrowed funds, resulting in significantly higher fee generation, up to 7x more than standard bots upon initial trade opening, growing exponentially as the trade appreciates in value. This model ensures both sustainability and maximized referral rewards, as leveraged position sizes create a larger fee base. Furthermore, our 4.5% roundtrip trading fee, compared to the industry standard of around 2%, reflects the added value and unique utility that 0xLeverage provides as the sole platform assuming the risk of leveraged lending in this way. This premium fee structure is justified by the exclusive utility we offer and the risk managed by 0xLeverage, delivering unmatched profitability for both traders and their referrers.\ \ Users can generate their personal referral link by sending /start to the[ 0xLeverage trading bot](https://t.me/LeverageTradebot), followed by /ref.\
This referral system provides all users who refer a new user with 25% of the referred users trading fees for life, there is no cap on referred users.\ \ Comparatively speaking, most trading bots offer in-between 10-25% for their referrals with no use of leverage.\ \ Referees can think of this system as quite literally, adding leverage to your referrals. # Roadmap # Leverage API # Intro # Handshake ## Handshake - Get your MTLS CERT\&KEY `POST` `/handshake` To access and utilize the full functionality of our API, you must obtain an MTLS (Mutual TLS) Certificate and key for secure authentication. **Important:** All API functions, except for **Handshake** and **Subscription**, mandate MTLS authentication. Without this authentication, access to these functions will be restricted. Ensure your MTLS credentials are properly configured before proceeding with the API integration. **Headers** | Name | Value | | ------------ | ------------------ | | Content-Type | `application/json` | **Body** | Name | Type | Description | | -------- | ------ | ----------- | | `apikey` | string | apikey | **Response** {% tabs %} {% tab title="200" %} ```json { "mtls_cert": , "mtls_key": , "status": "success", "message": "Handshake executed successfully, to execute API functions use the MTLS CERT and KEY attached to your apikey.", "timestamp": "2025-01-21 16:00:00" }, ``` {% endtab %} {% tab title="400" %} ```json { "status": "Failed", "message": "No data received or invalid JSON", "timestamp": "2025-01-21 16:00:00" }, ``` {% endtab %} {% tab title="401" %} ```json { "status": "Failed", "message": "API key is required", "timestamp": "2025-01-21 16:00:00" } ``` {% endtab %} {% tab title="402" %} ```json { "status": "Failed", "message": "Invalid API key", "timestamp": "2025-01-21 16:00:00" } ``` {% endtab %} {% tab title="403" %} ```json { "status": "Failed", "message": "Internal server error: Could not load MTLS data", "timestamp": "2025-01-21 16:00:00" } ``` {% endtab %} {% tab title="405" %} ```json { "status": "Failed", "message": "No MTLS data available", "timestamp": "2025-01-21 16:00:00" } ``` {% endtab %} {% tab title="500" %} ```json { "status": "Failed", "message": "Internal server error: ", "timestamp": "2025-01-21 16:00:00" } ``` {% endtab %} {% endtabs %} {% tabs %} {% tab title="JavaScript" %} ```javascript const fetch = require('node-fetch'); const url = "https://your-api-url.com/handshake"; const headers = { "Content-Type": "application/json" }; const payload = { apikey: "your_api_key" }; fetch(url, { method: "POST", headers: headers, body: JSON.stringify(payload) }) .then(response => response.json()) .then(data => console.log(data)) .catch(error => console.error("Error:", error)); ``` {% endtab %} {% tab title="Python" %} ```python import requests url = "https://your-api-url.com/handshake" headers = {"Content-Type": "application/json"} payload = {"apikey": "your_api_key"} response = requests.post(url, headers=headers, json=payload) print(response.json()) ``` {% endtab %} {% tab title="Typescript" %} ```typescript import fetch from 'node-fetch'; const url = "https://your-api-url.com/handshake"; const headers = { "Content-Type": "application/json" }; const payload = { apikey: "your_api_key" }; fetch(url, { method: "POST", headers: headers, body: JSON.stringify(payload) }) .then((response) => response.json()) .then((data) => console.log(data)) .catch((error) => console.error("Error:", error)); ``` {% endtab %} {% tab title="Go" %} ```go package main import ( "bytes" "encoding/json" "fmt" "net/http" ) func main() { url := "https://your-api-url.com/handshake" payload := map[string]string{ "apikey": "your_api_key", } payloadBytes, _ := json.Marshal(payload) req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes)) req.Header.Set("Content-Type", "application/json") client := &http.Client{} resp, err := client.Do(req) if err != nil { fmt.Println("Error:", err) return } defer resp.Body.Close() var result map[string]interface{} json.NewDecoder(resp.Body).Decode(&result) fmt.Println(result) } ``` {% endtab %} {% tab title="Rust" %} ```rust use reqwest::Client; use serde_json::json; use tokio; #[tokio::main] async fn main() -> Result<(), reqwest::Error> { let url = "https://your-api-url.com/handshake"; let client = Client::new(); let payload = json!({ "apikey": "your_api_key" }); let response = client .post(url) .json(&payload) .send() .await?; let response_text = response.text().await?; println!("{}", response_text); Ok(()) } ``` {% endtab %} {% endtabs %} # Quote Integrate our advanced Leverage API to enable on-chain leveraged trading within your application. Compatible with major blockchains like Solana, Ethereum, Base, Arbitrum, and Binance Chain. ## Request trade quote `POST` `/quote` Retrieve trade cost, liquidation price and current price **Headers** | Name | Value | Description | | ------------ | -------------------------------------- | ------------------------------------------------------------------------------------ | | Content-Type | `application/json` | Set to `application/json` to define the payload format. | | `cert` | **Python (requests):** tuple | Path to the certificate and key file as a tuple (e.g., `(cert_path, key_path)`). | | | **cURL:** `--cert` and `--key` | Separate paths to the certificate and key (e.g., `--cert cert_path --key key_path`). | | | **Java (Apache HttpClient)**: KeyStore | Certificate and key loaded into `SSLContext` or `KeyStore`. | **Body**
NameTypeDescription
apikeystringName of the user
network_choicestringSOL / ETH / BASE / ARB / BSC
contract_addressstringToken Address
leveragefloat e.g. 5.0. / 5.5 /
initial_amountfloat In Native e.g. 0.1 / 10.0 / 100
**Response** {% tabs %} {% tab title="200" %} ```json { "current_price": "0.00000006048819407141113196658559246834951927951352", "liquidation_price": "0.00000004637428212141520426252324109037128430088615", "message": "Quote executed successfully", "status": "success", "timestamp": "2025-01-21 15:59:48", "trade_cost": "0.0011" } ``` {% endtab %} {% tab title="400" %} {% code title="" %} ```json { "status": "Failed", "message": "Missing required fields", "timestamp": "2025-01-21 16:00:00" }, { "status": "Failed", "message": "No pair found for: contract_address_here", "timestamp": "2025-01-21 16:00:00" }, { "status": "Failed", "message": "Error fetching token price: Details here" "timestamp": "2025-01-21 16:00:00" }, { "status": "Failed", "message": "Trade cost error: Details here", "timestamp": "2025-01-21 16:00:00" } ``` {% endcode %} {% endtab %} {% tab title="401" %} ```json { "status": "Failed", "message": "Invalid API key", "timestamp": "2025-01-21 16:00:00" } ``` {% endtab %} {% endtabs %} {% tabs %} {% tab title="JavaScript" %} ```javascript const axios = require("axios"); const fs = require("fs"); const https = require("https"); const httpsAgent = new https.Agent({ cert: fs.readFileSync("path/to/certificate.crt"), key: fs.readFileSync("path/to/private.key"), }); axios.post("https://your-api-url.com/quote", { apikey: "your_api_key", network_choice: "ETH", contract_address: "0x03EE5026c07d85ff8ae791370DD0F4C1aE6C97fc", leverage: 5.0, initial_amount: 10.0, }, { httpsAgent }) .then(({ status, data }) => console.log(`${status}`, data)) .catch(({ response, message }) => console.error(response?.data || message)); ``` {% endtab %} {% tab title="Python" %} ```python import requests url = "https://your-api-url.com/quote" headers = {"Content-Type": "application/json"} payload = { "apikey": "your_api_key", "network_choice": "ETH", "contract_address": "0x03EE5026c07d85ff8ae791370DD0F4C1aE6C97fc", "leverage": 5.0, "initial_amount": 10.0 } CERT_PATH = "path/to/certificate.crt" KEY_PATH = "path/to/private.key" response = requests.post(url, headers=headers, json=payload, cert=(CERT_PATH, KEY_PATH)) print(response.status_code, response.json()) ``` {% endtab %} {% tab title="Typescript" %} ```typescript import fetch from "node-fetch"; import fs from "fs"; import https from "https"; const httpsAgent = new https.Agent({ cert: fs.readFileSync("path/to/certificate.crt"), key: fs.readFileSync("path/to/private.key"), }); fetch("https://your-api-url.com/quote", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ apikey: "your_api_key", network_choice: "ETH", contract_address: "0x03EE5026c07d85ff8ae791370DD0F4C1aE6C97fc", leverage: 5.0, initial_amount: 10.0, }), agent: httpsAgent, }) .then((res) => res.json()) .then(console.log) .catch(console.error); ``` {% endtab %} {% tab title="Rust" %} ```rust use reqwest::{Client, Certificate, Identity}; use serde_json::json; use tokio; #[tokio::main] async fn main() -> Result<(), reqwest::Error> { let client = Client::builder() .identity(Identity::from_pem(include_bytes!("path/to/identity.pem"))?) .add_root_certificate(Certificate::from_pem(include_bytes!("path/to/certificate.pem"))?) .build()?; let response = client .post("https://your-api-url.com/quote") .json(&json!({ "apikey": "your_api_key", "network_choice": "ETH", "contract_address": "0x03EE5026c07d85ff8ae791370DD0F4C1aE6C97fc", "leverage": 5.0, "initial_amount": 10.0 })) .send() .await? .text() .await?; println!("{}", response); Ok(()) } ``` {% endtab %} {% tab title="Go" %} ```go package main import ( "bytes" "crypto/tls" "encoding/json" "fmt" "io" "net/http" ) func main() { url := "https://your-api-url.com/quote" payload, _ := json.Marshal(map[string]interface{}{ "apikey": "your_api_key", "network_choice": "ETH", "contract_address": "0x03EE5026c07d85ff8ae791370DD0F4C1aE6C97fc", "leverage": 5.0, "initial_amount": 10.0, }) cert, err := tls.LoadX509KeyPair("path/to/certificate.crt", "path/to/private.key") if err != nil { fmt.Println("❌ TLS Error:", err) return } client := &http.Client{ Transport: &http.Transport{ TLSClientConfig: &tls.Config{Certificates: []tls.Certificate{cert}}, }, } resp, err := client.Post(url, "application/json", bytes.NewBuffer(payload)) if err != nil { fmt.Println("❌ Request Error:", err) return } defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) } ``` } {% endtab %} {% endtabs %} # Page 1 # Open Leverage trade # Close Leverage trade # Untitled # Whitelsted tokens **`POST`** **`/WLCHECK`** \ **Headers** | Name | Value | Description | | ------------ | -------------------------------------- | ------------------------------------------------------------------------------------ | | Content-Type | `application/json` | Set to `application/json` to define the payload format. | | `cert` | **Python (requests):** tuple | Path to the certificate and key file as a tuple (e.g., `(cert_path, key_path)`). | | | **cURL:** `--cert` and `--key` | Separate paths to the certificate and key (e.g., `--cert cert_path --key key_path`). | | | **Java (Apache HttpClient)**: KeyStore | Certificate and key loaded into `SSLContext` or `KeyStore`. | **Body** | Name | Type | Description | | ----------------- | ------ | ------------- | | apikey | string | APIKEY | | contract\_address | string | Token address | **Response** {% tabs %} {% tab title="200" %} ```json { "message": "Whitelisted" } -------------------------------------------------------------------------------- } "message": "Not whitelisted" } ``` {% endtab %} {% tab title="500" %} ```json { "message": "Internal server error" } ``` {% endtab %} {% endtabs %} {% tabs %} {% tab title="JavaScript" %} ```javascript const axios = require('axios'); const fs = require('fs'); const certFilePath = "path/to/certificate.crt"; const keyFilePath = "path/to/private.key"; const url = "https://api.0xleverage.io/is_whitelisted"; const payload = { contract_address: "0x1234567890abcdef1234567890abcdef12345678" }; axios.post(url, payload, { headers: { "Content-Type": "application/json", }, httpsAgent: new require('https').Agent({ cert: fs.readFileSync(certFilePath), key: fs.readFileSync(keyFilePath), }), }).then(response => { console.log(response.status, response.data); }).catch(error => { console.error(error.response ? error.response.data : error.message); }); ``` {% endtab %} {% tab title="Python" %} ```python import requests cert_tuple = (cert_file_path, key_file_path) url = "https://api.0xleverage.io/is_whitelisted" payload = {"contract_address": "0x1234567890abcdef1234567890abcdef12345678"} headers = {"Content-Type": "application/json"} response = requests.post(url, json=payload, cert=cert_tuple, headers=headers) print(response.status_code, response.json()) ``` {% endtab %} {% tab title="Typescript" %} ```typescript import axios from 'axios'; import * as fs from 'fs'; const certFilePath: string = "path/to/certificate.crt"; const keyFilePath: string = "path/to/private.key"; const url: string = "https://api.0xleverage.io/is_whitelisted"; const payload = { contract_address: "0x1234567890abcdef1234567890abcdef12345678" }; axios.post(url, payload, { headers: { "Content-Type": "application/json", }, httpsAgent: new (require('https').Agent)({ cert: fs.readFileSync(certFilePath), key: fs.readFileSync(keyFilePath), }), }).then(response => { console.log(response.status, response.data); }).catch(error => { console.error(error.response ? error.response.data : error.message); }); ``` {% endtab %} {% tab title="Golang" %} ```go package main import ( "bytes" "crypto/tls" "encoding/json" "fmt" "io/ioutil" "net/http" ) func main() { certFile := "path/to/certificate.crt" keyFile := "path/to/private.key" cert, err := tls.LoadX509KeyPair(certFile, keyFile) if err != nil { fmt.Println("Error loading certificate and key:", err) return } client := &http.Client{ Transport: &http.Transport{ TLSClientConfig: &tls.Config{ Certificates: []tls.Certificate{cert}, }, }, } url := "https://api.0xleverage.io/is_whitelisted" payload := map[string]string{ "contract_address": "0x1234567890abcdef1234567890abcdef12345678", } payloadBytes, _ := json.Marshal(payload) req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes)) if err != nil { fmt.Println("Error creating request:", err) return } req.Header.Set("Content-Type", "application/json") resp, err := client.Do(req) if err != nil { fmt.Println("Error making request:", err) return } defer resp.Body.Close() body, _ := ioutil.ReadAll(resp.Body) fmt.Println("Status Code:", resp.StatusCode) fmt.Println("Response:", string(body)) } ``` {% endtab %} {% tab title="Rust" %} ```rust use reqwest::blocking::Client; use reqwest::Certificate; use std::fs; fn main() -> Result<(), Box> { let cert = fs::read("path/to/certificate.crt")?; let key = fs::read("path/to/private.key")?; // Combine cert and key to use with reqwest let identity = reqwest::Identity::from_pem(&[cert, key].concat())?; let client = Client::builder() .identity(identity) .build()?; let url = "https://api.0xleverage.io/is_whitelisted"; let payload = serde_json::json!({ "contract_address": "0x1234567890abcdef1234567890abcdef12345678" }); let response = client .post(url) .json(&payload) .header("Content-Type", "application/json") .send()?; println!("Status Code: {}", response.status()); println!("Response: {}", response.text()?); Ok(()) } ``` {% endtab %} {% endtabs %} # 0xLeverage Token Welcome To The Heart Of The 0xLeverage Ecosystem \ \ [0x03ee5026c07d85ff8ae791370dd0f4c1ae6c97fc](https://etherscan.io/address/0x03ee5026c07d85ff8ae791370dd0f4c1ae6c97fc#code) # $0XL Tokenomics * 5% buy tax (adjustable tax allocation between leverage pool, marketing wallet and liquidity pool) * 5% sell tax (adjustable tax allocation between leverage pool, marketing wallet and liquidity pool) * 100% of tokens went to the liquidity pool * ZERO team allocation * No private sale * No presale
# $0XL Token Revenue Share The true benefits of the $0XL token lie in its utility. Token holders with a minimum of 2.5 million $0XL tokens are eligible for revenue sharing profits, allowing them to receive a revenue share of 50% of all trading fees. \ \ This distribution of fees is proportional to the amount of tokens held within each wallet. With a total supply of 1B, the minimum holding amount required to participate in the revenue-sharing model is 0.25% of the total supply.
# Token Links \ \
{% tabs %} {% tab title="Token Contract" %} [0xLeverage Contract Etherscan](https://etherscan.io/token/0x03ee5026c07d85ff8ae791370dd0f4c1ae6c97fc) {% endtab %} {% tab title="Dextools $0XL Chart" %} [0xLeverage Chart Dextools](https://www.dextools.io/app/en/ether/pair-explorer/0x0ae8d75e6168420a7d52a791c2465b43307408b4) {% endtab %} {% tab title="CoinGecko" %} [0xLeverage CoinGecko](https://www.coingecko.com/en/coins/0x-leverage) {% endtab %} {% tab title="$0XL Uniswap" %} [0xLeverage Uniswap](https://app.uniswap.org/swap?outputCurrency=0x03ee5026c07d85ff8ae791370dd0f4c1ae6c97fc) {% endtab %} {% tab title="CoinMarketCap" %} [$0XL Coin Market Cap](https://coinmarketcap.com/currencies/0x-leverage/) {% endtab %} {% endtabs %} # 0XLBOTs NFT Overview 0xlBOT NFTs will continue to provide additional perks for users beyond the original use-case of BETA access to the 0xleverage trade bot. These utilities are not finalized and are subject to change. For users interested in obtaining an 0XLBOT NFT please refer to the NFT links section found [here](/0xlbot-nft-links).\
# 0XLBOT NFT Links {% tabs %} {% tab title="Minting dApp" %} [0XLBOT NFT Minting dApp](https://mint.0xleverage.io/) {% endtab %} {% tab title="Opensea" %} [Opensea 0XLBOT Collection Page](https://opensea.io/collection/0xlbots-official) {% endtab %} {% tab title="Contract" %} [Etherscan Contract](https://etherscan.io/address/0x2d018d51dd6ce858f4bf266521ca13059d607efc) {% endtab %} {% endtabs %} # Trading Assets with 0xLeverage Trading assets with 0xLeverage is your gateway to exploring the world of DeFi markets with confidence and precision
Diverse Asset Coverage 0xLeverage opens the door to a diverse array of DeFi assets, allowing you to explore opportunities across different markets. From well-established cryptocurrencies to emerging tokens, our platform offers access to a wide spectrum of assets. This diversity enables you to tailor your trading strategy to your preferences and risk appetite.
Leverage Trading Take your trading to the next level with our leverage bot. This powerful tool allows you to open leveraged positions on select tokens, magnifying your exposure to potential gains. You can choose from various leverage options, including 2x-7x, while our safety parameters ensure that your trades remain secure.
Risk Management We understand that managing risk is crucial in the volatile world of DeFi. That's why our leverage bot offer risk management features. Set stop-loss and take-profit levels to mitigate potential losses and secure profits automatically.
Real-Time Insights Keeping tabs on your trades is essential for informed decision-making. With our real-time tracking capabilities, you can monitor your positions and make adjustments as market conditions evolve. The /tracklev command provides you with instant updates on your leveraged positions.
# Funding & Transferring Assets **Funding:** When funding your bot generated wallets, it is as simple as sending Ethereum (ETH) to the desired public address generated by the 0xLeverage bot. (Same process for all supported chains, just send the native chain currency to the first wallet.)\ \ When funding for leverage trading, you must send ETH to the first wallet generated for you as this wallet is the only wallet used for the leverage trading feature. Access this wallet address by using the /balances command within the bot chat.
**Transferring Assets:** When you need to transfer your ETH balance to another wallet address simply use the /balances command, and click the 'Transfer Out' button at the bottom of the bot reply.
This will prompt the transfer process of inputting the desired chain, sender address (your wallet you are sending from), receiver address (the address you want to send to), and transfer amount (in ETH).
Once these steps are completed, the transfer will begin and the funds will be sent to the desired wallet address. # Trade Example Walkthrough When you begin, click the 'start' button within the bot
You will then be prompted with your wallets and private keys.\ \ Be sure to store these keys adequately as they will only be shown once and the team has no access to them in the event of loss of keys.
Use the /start command to have the bot prompt you with the essential commands to get started.
Be sure to set your Gwei and slippage by using the /settings command, remember that this gwei is additional on top of the market gwei amount to ensure your trade is successful.
Simply paste a contract address into the chat and you will be presented with the trading bot menu.
For regular trades, set your parameters and open trade, for leverage trades click 'leverage menu'
For leverage trades, select your parameters and click open trade.
Your trade is now open! Use /tracklev to get real time updates on your position
To close your trade, simply click 'Close Trade' and the process will reverse with your PNL sent back to your wallet, if liquidation occurs you will be prompted via a bot message.
But with great risk, can come great reward! Be sure to share your gains when you make the right call!
Happy leverage trading! # Multiple Open Trades On Single Contract When a user opens two leverage trades simultaneously on the same asset, the two trades share risk, particularly in the context of liquidation. If the price of the asset moves unfavourably, reaching the liquidation threshold, it triggers the liquidation process for both open positions. Similarly when the asset moves up in price, you will reap the rewards on both positions. Let's say a user decides to open two leverage trades on the same asset, both involving the same asset. Each trade has its own leverage level, position size, and liquidation price. Since both trades are based on the same asset, their outcomes are interconnected. If the price of the asset moves in a way that meets the liquidation price for one of the trades, it will result in the liquidation of both trades. Users can manage this risk by diversifying their trades across different assets or by adjusting leverage levels and position sizes strategically and setting and monitoring stop-loss orders can help mitigate the risk of large losses in the event of negative price movements. # Understanding Risk & How To Mitigate It In the unpredictable realm of cryptocurrencies, especially DeFi, effective risk management is not just an option; it's a necessity 0xLeverage recognizes the importance of safeguarding your investments in this highly volatile market. That's why we've integrated risk management features into both our regular and leverage trading bots, providing you with a safety net and precise control over your trades.\ \ **Stop-Loss Orders:** Think of stop-loss orders as your financial safeguards. They act as predefined thresholds that automatically trigger the sale of your assets when the market moves against your position. By setting a stop-loss level, you establish the maximum loss you are willing to bear on a trade. This feature helps mitigate losses during sudden market fluctuations, ensuring that you can sleep soundly, knowing your investments are shielded. **Take-Profit Orders:** Take-profit orders are your way of locking in gains. They enable you to set specific price points at which your assets will be sold automatically, securing profits when the market moves in your favor. By doing so, you can ensure that you don't miss out on potential profits or let fleeting opportunities slip through your fingers.\ \ **Peace of Mind:** The beauty of these risk management tools is that they operate automatically. Once you've set your stop-loss and take-profit levels, you can trade with peace of mind, knowing that your positions are under constant surveillance. You won't need to monitor the markets around the clock; the bot does it for you. **Adaptable to Both Bots:** Whether you're engaged in regular trading or exploring the world of leverage, our risk management features are at your disposal. They are seamlessly integrated into both trading bots, providing a consistent and user-friendly experience.\ \ In the end, risk management is not just about protecting your investments; it's about maximizing your potential in the DeFi market. With 0xLeverage's advanced risk management tools, you can navigate the volatility of cryptocurrencies with confidence, secure profits, and minimize losses – all with the precision and ease that our bot provides.
# Gas Prices & Tax with 0xLeverage When opening trades with 0xLeverage, the associated costs due to gas prices and token tax are covered by the user. An additional 0.05 ETH will be added to the leverage wallet to cover these costs, and what is left over will be stored in the users dedicated leverage wallet to lower the amount of additional ETH needed for the users next trade. This is only applicable to trades being made on the Ethereum main-net due to its high gas costs, and will be substantially less on any other blockchain 0xLeverage incorporates into its ecosystem. \ \ Here you will find some key information as to how the can affect your 0xLeverage experience, and how to maximize benefits and mitigate losses due to gas costs.\ \ (Above information pertains to ETH main net only, as our integration with alternative blockchains significantly reduce gas fee's. Gas costs taken by 0xLeverage on alternative blockchains can be decreased by as much as 10x and result in cheaper transactions.)\ \ **Solana Transaction Costs**\ \ On Solana, the transaction process is different. Instead of large single gas charges, trades are executed through a bundled set of smaller transactions. Each transaction incurs a minimal network fee and a JITO tip. The JITO tip is used to prioritize your transaction and improve execution speed. In most cases, the total cost of both the gas priority fee and JITO tip is under 0.01 SOL. Users can adjust their settings to pay higher tips for faster throughput or lower them to reduce costs, understanding that this may slightly reduce execution priority. The fees are taken directly from your wallet at the time of trade and are not preloaded into the leverage wallet.
# Gas Information **What Are Gas Fees?** Gas fees are the costs associated with processing and validating transactions on the Ethereum blockchain. They serve as incentives for miners to include your transaction in a block. In times of high network demand, these fees can climb to higher levels. **Gas Fees and Leverage Trading** As enthusiastic traders, you're eager to leverage your positions, aiming for significant profits. However, it's crucial to account for gas fees when using 0xLeverage. This is how gas fees can influence your trading experience. **Sizing your position** One of the attractive features of 0xLeverage is the ability to trade micro-cap tokens with position sizes between $5-2000 USD. While this opens up opportunities for traders with smaller capital, gas fees can pose a challenge, especially when they increase significantly. **Cost of Gas** Gas fees are denominated in ETH. When gas prices surge, as often happens during periods of high network activity, the cost of executing transactions can be increased substantially. This means that if you're trading a position size of say, 50 USD, but the gas fees for opening, managing, and closing the trade amount to 50 USD, you effectively double your entry cost. As a trader, you need to strike a balance. The potential gains from leveraging your position should outweigh the total cost, including gas fees. Here are some strategies to consider: \ **1. Cost-Benefit Analysis:** Before opening a trade, assess the gas fees associated with it. Ensure that your profit potential justifies the additional expenses. For very small positions, high gas fees can significantly eat into your gains. \ **2. Timing Matters:** Keep an eye on Ethereum network activity. Gas fees tend to be lower during periods of lower congestion. Consider opening trades during these windows to optimize your costs. Users can use /gas to check the current market gas prices. \ **3. Leverage Responsibly:** Higher leverage might seem appealing, but it can also mean more transactions and, subsequently, higher gas costs. Choose your leverage wisely, keeping gas fees in mind. \ **4. Stay Informed:** Regularly check gas fees and consider using our Ethereum gas fee tracking command, /gas to anticipate costs accurately. # Tax Information At 0xLeverage, we are constantly improving the user experience and the security and solvency of our leverage pool. When users are trading tokens which have set taxation in their smart contracts, they will need to cover the token tax each time they enter a trade, ensuring a more transparent and fair trading environment. **How it Works:** 1. **User Intent:** * User decides to open a $100 trade at 5x leverage * Initial user funds: $100 * Leverage funds: $400 2. **Tax Calculation:** * Assume the token has a 5% buy and 5% sell tax * 10% (5% buy + 5% sell) tax on a $500 (user funds + borrowed funds) trade amounts to $50 3. **Prepaid Tax Transaction:** * Before the trade is executed, the bot will initiate a separate transaction to prepay the $50 tax, meaning the user needs to have adequate funds to cover both [gas fees](https://docs.0xleverage.io/best-practices/gas-prices-and-tax-with-0xleverage) and tax fees * This tax is sent to another wallet separate from the trading wallets 4. **Total Funds Committed:** * User funds for the trade: $100 (initial) + $400 (borrowed) + $50 (prepaid tax) = $550 **Why Prepay Tax?:** * Protects the leverage pool by ensuring tax is covered upfront * Prevents users from starting a trade at an automatic loss due to additional tax fees * Lowers the liquidation level, offering a more secure trading environment **User Benefits:** * Greater clarity and transparency in trade costs * Reduced risk of unexpected losses due to tax fees # Personal Security Always Keep Your Funds Safe The auto-generated wallets and their private keys are securely stored on a dedicated encrypted server, and it's crucial to emphasize that our team has absolutely no access to them. However, it's essential to remain vigilant and adhere to standard security practices for safeguarding your keys. Please note that once your keys have been displayed within your Telegram message thread with the bot, 0xLeverage cannot retrieve them, nor can we assume responsibility for their security. Protection against potential threats, such as malware, prying eyes, Telegram phishing scams, or similar risks, fall within the user's responsibility to address and defend against.\ \ Once the wallets and their keys have been displayed, we recommend you follow [best security practices](https://chainstack.com/how-to-store-private-keys-securely/) as you would with any other private key or seed phrase, as these are the master key to your funds.\ \ Funding the wallets with the minimum amount for you to complete the intended transactions is recommended, and storing all other funds on a [cold storage](https://trezor.io/) device then funding the bot wallets when needed is the suggested method for staying secure. # Technical Overview Technical Confidentiality & Safeguarding Our Intellectual Property In the world of new technology, discretion is crucial for success. Our commitment to technical confidentiality ensures that we continue to lead the way in the evolution of leverage trading bots while protecting the innovation that sets us apart.
Preserving Our Unique Position As first-movers in the development of a leverage trading bot, our status as an innovator is invaluable. By keeping our codebase private, we shield our intellectual property from potential competitors who might attempt to replicate our utility.
Guarding Against Copycats The uniqueness of our bot means that there is no precedent to follow. An open-source codebase could inadvertently pave the way for copycat versions, diluting our distinctive offering in the market. Confidentiality preserves our competitive edge.
Technical Exploration In the upcoming "Technicals" section, we will delve into the intricate details of our leverage pool, trade logistics, liquidation mechanisms, and revenue model. While we are committed to sharing technical insights, we do so in a manner that safeguards our codebase's confidentiality.
Innovation Unleashed Our closed-source approach enables us to innovate freely and push the boundaries of what's possible in leverage trading. It allows us to experiment, iterate, and refine our code without concerns about exposing sensitive information to the public.
# Trade Logistics Streamlined Trade Logistics: A Detailed Insight
EVM Chains (Ethereum, Base, BNB Chain) 1\. Selecting Trade Parameters When you open a trade, you set your position size and desired leverage. These choices define the trade’s risk and potential returns. \ 2\. Fund Allocation Your funds are sent to a dedicated third “user leverage wallet,” separate from both your wallet and the leverage pool. This keeps user funds and pool funds fully separate at all times. \ 3\. Leverage Pool Involvement The bot sends the borrowed portion from the leverage pool to the same “user leverage wallet” based on your chosen leverage. \ 4\. Trade Execution Once the wallet holds both your funds and the borrowed funds, the bot executes the trade in the selected asset. \ 5\. Tracking Trades Use the /tracklev command to monitor open positions and see live PNL updates. \ 6\. Closing the Trade When you close your trade, borrowed funds are returned to the leverage pool, and the remaining funds (minus fees) are sent back to your wallet. \ 7\. Gas Fees Leverage trades on EVM chains involve multiple transactions, so an extra 0.05 ETH is required to cover gas. Any unused amount is returned after the trade closes. Other chains have lower gas requirements. \ Solana On Solana, transactions are bundled through several processes. Each process incurs a very small fee, including your gas priority fee and a JITO tip. This bundling ensures fast entries and exits, and the fees are taken directly from your wallet. In most cases, the total cost is less than 0.1 SOL. \ You can adjust your settings to increase throughput by paying more, or reduce costs by lowering your throughput priority. The flow of funds from your wallet to the leverage wallet, then to purchase the asset and back, is similar to EVM chains but not identical. For a deeper understanding of Solana trade execution, we recommend learning more about JITO and the Solana network’s bundled transactions. # Liquidations Navigating Liquidations: A Balanced Approach
In the world of leverage trading, liquidations are a critical aspect of risk management. Here's how we handle them: **Determining Liquidation Threshold**: To strike a balance between user fairness and risk mitigation, our liquidation threshold is set at -70% of user funds concerning a price decrease. This threshold was chosen to ensure that neither users nor the team assume undue risk. If set too low, it wouldn't be equitable to users, and if set too high, it could expose the team to excessive risk due to price volatility. Some basic calculations for liquidations are as follows:\ \ 2x - 35% price decrease on initial \ 3x - 24% price decrease on initial \ 4x - 18% price decrease on initial \ 5x - 14% price decrease on initial\ 10x - 7% price decrease on initial **Automatic Liquidation Process**: When a liquidation event occurs, the bot automatically initiates the sale of the user's position in an attempt to recoup the borrowed funds provided by 0xleverage. The proceeds are then returned to the leverage pool, ensuring the continued stability of the trading ecosystem. **User Notification**: In the event of a liquidation, users are notified. This transparent communication allows users to stay informed about the status of their positions. **Mitigating Total Loss**: Stop-loss mechanisms are available to users to mitigate the risk of total liquidation. It is always encouraged for users to carefully consider and set these levels to align with their risk tolerance and understanding of the volatile nature of the DeFi landscape. Our approach to liquidations prioritizes fairness and risk management. It combines a carefully selected liquidation threshold with an automatic process that seeks to protect both users and the integrity of our leverage trading ecosystem. Users are encouraged to utilize stop-loss features and exercise caution, bearing in mind the high level of volatility with leverage trading microcap DeFi tokens. # Leverage Pool Where Funding Meets Security The 0xLeverage dedicated leverage pool is secured through cold storage. The leverage wallets for each individual supported network are topped up when needed and kept within parameters to make sure each pool is not overstocked or understocked, allowing for users to always have access to trading funds, while mitigating loss in the very unlikely event of an exploit.\
# Revenue Model Ensuring Profitability For Both The Protocol & The User Our protocol currently operates on three primary revenue models. \ Buy and Sell Fees The bot charges a 3% buy fee and a 2.5% sell fee on every leverage trade. This is calculated on the total position size, which includes both the user’s initial funds and borrowed funds. For example, a trade with 5x leverage on a $100 initial investment would have the buy fee calculated on $500, not just the $100 initial. The same applies to the sell fee, which is taken from the total sold amount regardless of whether the trade was in profit or loss. \ API Whitelabel Integration Teams that integrate our utility as a whitelabel service will operate under a hardcoded fee structure. A percentage of fees generated by their project will automatically be sent to 0xLeverage. These fees will be added to our revenue pool and distributed to revenue share holders using the same 50% model. \ Revenue Share to Holders As outlined in the revenue share section, 50% of all revenue generated from both buy and sell fees and API whitelabel integrations is distributed to holders with at least 0.25% of the 0xLeverage token supply (2.5 million tokens). To date, more than $150,000 USD (45 ETH) has been distributed to holders from real bot-generated revenue.\
# Bot Generated Wallet Security Enhancing User Security with Auto-Generated Wallets At the core of our commitment to user security is our innovative approach to auto-generated wallets. Here's how we prioritize your safety: **Private Key Protection**: Your security is priority number one. That's why we ensure that private keys for these wallets are beyond reach, even for our team. They are securely stored on dedicated encrypted servers, employing industry-standard measures to safeguard them from any unauthorized access. With this does come the responsibility of maintaining your private keys securely, as you would with any other wallet. If you lose your keys, you lose your funds. We can not recover your bot generated wallets for you in any case. **Hands-Off User Funds**: Rest assured, your funds are yours and yours alone. Our team has no access to user funds. This separation of responsibilities and access ensures that your assets remain entirely under your control. **99.9% Server Uptime**: Our bot server hosts an impressive uptime record of over 99%. This high availability ensures that you can access and manage your positions with reliability and peace of mind. # Leverage Pool Security Security Measures for the Leverage Pool Security is the foundation of our leverage pool's operations, and we have implemented an industry standard framework to ensure the protection of the leverage pool assets. **Diversified Warm Wallets**: Our leverage pool is strengthened by the presence of multiple warm wallets, each equipped with unique private keys and seed phrases. This diversification adds an additional layer of security by mitigating the risks associated with a singular point of compromise. These wallets are actively involved in the allocation and management of funds. **Strategic Capital Management**: While a significant portion of the leverage pool's capital resides in a secure cold wallet, our approach is dynamic and adaptive. Funds are selectively transferred to warm wallets when required, allowing us to minimize risk exposure. This strategy ensures that only the necessary amount of capital is exposed to the trading environment at any given time. **User Asset Isolation**: An essential aspect of our security protocol is the segregation of user funds from the leverage pool itself. This fixed boundary guarantees that your assets remain entirely separate from the leverage pool itself. Our security measures underscore our commitment to safeguarding the leverage pool. They establish a framework that effectively mitigates risks, ensuring the safety of your investments. Your peace of mind is of utmost importance to us, and our dedication to security reflects this. # Disclaimer **Legal and Regulatory Compliance:** 0xLeverage is a decentralized finance (DeFi) platform designed to provide leverage trading services for cryptocurrencies. It is imperative for users to be aware that their access and use of 0xLeverage may be subject to the laws and regulations of their respective geographic locations. Users are solely responsible for understanding and complying with the legal requirements pertaining to cryptocurrency and DeFi usage in their jurisdiction. 0xLeverage does not assume responsibility for any user's legal obligations. **Risk Acknowledgment:** While 0xLeverage offers a trading bot designed to enhance trading opportunities, users must acknowledge that cryptocurrency trading, including leverage trading, involves substantial risk. The percentage gains displayed by the bot do not account for fees, taxes, or price impacts that may affect the actual returns on your investments. It is crucial to recognize that trading cryptocurrency carries inherent risks, and past performance is not indicative of future results. **User Responsibility:** Users of 0xLeverage must trade responsibly and within their financial means. We strongly advise against trading with more capital than you can afford to lose. The cryptocurrency market is known for its volatility, and while potential rewards can be significant, the risk of losses is equally substantial. Users should conduct thorough research and consider their risk tolerance before engaging in cryptocurrency trading. **No Liability:** 0xLeverage and its team disclaim any liability for financial losses or legal consequences incurred by users in connection with their use of the platform. Users are encouraged to exercise caution and diligence when trading cryptocurrencies and to seek independent legal and financial advice if necessary.\ \ **BETA Testing Phase For New Version Roll-outs:** As we continue to BETA test our utilities, all users accept the risk of potential losses through unexpected technical difficulties using the associated utilities offered by 0xLeverage. By accessing and using 0xLeverage, users acknowledge and accept the terms of this disclaimer, understanding that they are solely responsible for their actions and decisions within the platform. # FAQ Frequently Asked Questions We have a lot of frequently asked questions surrounding our product and protocol. If you do not see your question below, please feel free to reach out in the [Telegram](https://t.me/LeveragebotSupport)[ Public Support](https://t.me/LeveragebotSupport) as we are happy to answer any query you may have.
How do I qualify for $0XL revenue sharing, and what are the benefits? $0XL revenue sharing is simple; you can do it through our platform by holding a minimum of 2.5 million $0XL tokens, which is equivalent to 0.25% of the total supply. This qualifies your wallet as eligible for the revenue share airdrops.
What security measures are in place to protect all funds? We prioritize security by employing advanced measures, such as auto-generated wallets with private keys stored on dedicated encrypted servers. Most importantly, our team has no access to user funds, and our bot server maintains an uptime of over 99%.
Can you explain the risk management features and the liquidation process? Our liquidation process triggers at -70% of user funds concerning a price decrease. This threshold was chosen to strike a balance between user fairness and risk mitigation. Users are encouraged to set stop-loss levels to mitigate total liquidation and understand the volatility of the DeFi landscape before opening any position.
What sets your leverage trading bot apart from others in the market? Our leverage trading bot stands out due to its unique combination of features, including the ability to open 1x to 7x long positions on a wide range of tokens. We offer real-time position tracking, auto-generated wallets for security, and a meticulous approach to risk management, trading bots, and as of now we are the only leverage trading bot in the blockchain space.
Where can I access the bot? t.me/leveragetradebot
How does the protocol make profit when everyone is winning? The protocol makes revenue by taking a percentage of each position, as well as a fee on liquidations, so whether a position profits greatly, or reaches its liquidation price, the protocol receives funds to inject back into the leverage pool.
Can I short tokens? No, offering short positions on microcap tokens exposes the leverage pool to a number of unavoidable risks, as well as subjecting the protocol to taking on the role of a market maker, where short positions need to be filled at the expense of the leverage pool.\ \ Longing allows both the user and the protocol to be profitable on the same position, allowing for scalability into the future.
# 0xLeverage API (coming soon) The 0xLeverage API is under development and will allow for existing projects from any sector to integrate 0xLeverage utilities directly into their utilities. \ \ This API can be integrated as a white label solution, or as a direct integration with 0xLeverage and is entirely up to the integrator.\ \ Custom branding templates will allow for integrators to brand their PNL cards whatever way they like.\ \ Further API documentation will be updated here as we near completion of the product itself.