DEX vs CEX Arbitrage Guide: क्रिप्टो में स्प्रेड ट्रेडिंग कैसे करें

स्प्रेड की एनाटॉमी: DEX और CEX कभी 100% सिंक में क्यों नहीं रह सकते

अगर आपको लगता है कि DEX और CEX के बीच आर्बिट्राज (Arbitrage) कोई "छापने की मशीन" है—जहाँ बस 2% का गैप देखा, कॉइन्स इधर से उधर ट्रांसफर किए और काम हो गया—तो भाई, बहुत बड़ा झटका लगने वाला है। इंटर-एक्सचेंज स्प्रेड कोई मुफ़्त का पैसा नहीं है; यह इलिक्विडिटी, एग्जीक्यूशन स्लिपेज और इंफ्रास्ट्रक्चर के लैग का रिस्क प्रीमियम है।

CEX (जैसे Binance, Bybit, EXMON) पर प्राइस डिस्कवरी लिमिट ऑर्डर बुक (Limit Order Book) के अंदर होती है। वहाँ लिक्विडिटी एकदम डायनामिक होती है: मार्केट मेकर्स माइक्रोसेकंड्स में अपनी ऑर्डर ग्रिड बदलते हैं, और एल्गोरिदम फ्यूचर्स इंडेक्स के बेसिस पर लगातार फेयर वैल्यू कैलकुलेट करते रहते हैं।

दूसरी तरफ DEX (जैसे Uniswap, Raydium, PancakeSwap) पर प्राइस पूरी तरह से लिक्विडिटी पूल के मैथमेटिकल कर्व पर टिकी होती है। एक क्लासिक AMM v2 (x · y = k) में प्राइस तभी हिलती है जब पूल में ऑन-चेन कोई ट्रांजैक्शन फिजिकली हिट करती है। अगर Binance पर किसी व्हेल के बेचने से टोकन X की प्राइस एक सेकंड में 5% गिर जाती है, तो Uniswap का पूल अपनी पुरानी हाई प्राइस पर ही अड़ा रहेगा, जब तक कि:

• किसी आर्बिट्राज बॉट की ट्रांजैक्शन नेटवर्क पर ब्रॉडकास्ट न हो जाए।
• वह ट्रांजैक्शन ब्लॉक में वैलिडेट होकर माइन न हो जाए।

इसी टाइम गैप के बीच (जो तेज़ नेटवर्क पर कुछ सेकंड से लेकर Ethereum पर कुछ ब्लॉक्स तक हो सकता है) असली स्प्रेड का जन्म होता है।

डीप डाइव: मैन्युअल ट्रेडर्स के लिए स्प्रेड कहाँ से आता है?

मैन्युअली ट्रेड करके आप HFT बॉट्स और MEV सर्चर्स से कभी मुकाबला नहीं कर सकते, जो प्राइवेट RPC नोड्स चला रहे हैं और Flashbots के ज़रिए वैलिडेटर्स को टिप देकर उसी ब्लॉक में बैकरनिंग (backrunning) कर लेते हैं। ETH या BTC पर 0.2%–0.5% का छोटा-मोटा स्प्रेड तो ये एल्गोरिदम माइक्रोसेकंड्स में चट कर जाते हैं।

मैन्युअल आर्बिट्राज ट्रेडर्स बिल्कुल अलग तरह की प्राइस मिसमैच की ताक में रहते हैं:

• मिड-कैप ऑल्टकॉइन्स में इम्पल्सिव डंप/पंप। DEX पूल में कोई "व्हेल" आती है और $50,000 के टोकन मार्केट-सेल कर देती है। कम लिक्विडिटी वाले पूल में प्राइस तुरंत 4–7% क्रैश कर जाती है। CEX के बॉट्स इस डिप को तुरंत बाय बैक नहीं कर पाते, क्योंकि CEX पर ऑर्डर बुक काफी थिक होती है और वहाँ प्राइस में कोई बदलाव नहीं हुआ होता।
• नेटवर्क कंजेशन और गैस प्राइस में स्पाइक। जब मार्केट में भयंकर वोलेटिलिटी होती है, तो मेमपूल (mempool) पूरी तरह जाम हो जाता है। MEV बॉट्स या तो कुछ देर के लिए पीछे हट जाते हैं या भारी-भरकम गैस फीस मांगने लगते हैं, जिसकी वजह से DEX पर स्प्रेड 2–5 मिनट तक बना रह सकता है।
• अन-सिंक लिस्टिंग और डिपॉजिट/विड्रॉल का हॉल्ट होना। किसी नोड अपडेट या चेन मेंटेनेंस की वजह से CEX किसी खास नेटवर्क पर टोकन का डिपॉजिट या विड्रॉल रोक देता है। DEX और CEX के बीच का लिक्विडिटी ब्रिज पूरी तरह टूट जाता है। CEX की ऑर्डर बुक एक बंद कमरा बन जाती है, और वहाँ प्राइस अपनी अलग ही दुनिया में चलने लगती है—DEX से 15%+ तक डीकपल्स हो जाती है।

ट्रेडिंग सेटअप का आर्किटेक्चर और कैपिटल एलोकेशन

नये ट्रेडर्स की सबसे बड़ी बेवकूफ़ी: DEX पर स्प्रेड देखा, CEX पर बाय किया, "Withdraw to Wallet" दबाया और 15 मिनट तक चेन कन्फर्मेशन का इंतज़ार करते रहे। जब तक टोकन आपके वेब3 वॉलेट में पहुँचते हैं, स्प्रेड गायब तो होता ही है, साथ ही आप पक्के नुकसान (guaranteed loss) में ट्रेड क्लोज करते हैं।

मैन्युअल स्प्रेड ट्रेडिंग के लिए डेल्टा-न्यूट्रल (delta-neutral) सेटअप या पहले से स्प्लिट किए गए बैलेंस की ज़रूरत होती है।

स्प्लिट बैलेंस (Split Balance) मॉडल

चालू ट्रेड के दौरान प्लेटफ़ॉर्म्स के बीच फंड्स ट्रांसफर करने का विचार दिमाग से निकाल दें। फंड ट्रांसफर ट्रेडिंग शुरू करने से पहले ही कर लिए जाते हैं।

आपका कुल कैपिटल दो बराबर हिस्सों में बँट जाता है:

इस सेटअप के साथ आप दोनों तरफ़ एक साथ ऑर्डर्स एग्ज़ीक्यूट करते हैं:

• अगर ARB टोकन DEX पर $1.10 और CEX पर $1.00 का मिल रहा है: आप तुरंत DEX पर अपना ARB सेल करते हैं ($1.10 जेब में डालते हैं) और CEX पर उतना ही ARB बाय कर लेते हैं ($1.00 पर)।
• इवेन्यू में कोई ऑन-चेन टोकन ट्रांसफर नहीं हुआ। आपने बिना किसी झंझट के 3 सेकंड के अंदर 10% का डेल्टा (फीस काटकर) जेब में डाल लिया।
• अपने वॉलेट और एक्सचेंज के बीच फंड्स का रीबैलेंसिंग (Rebalancing) आप बाद में आराम से करते हैं—जब मार्केट शांत हो जाए और नेटवर्क गैस फीस एकदम बॉटम पर आ जाए।

ट्रेड का गणित: 'नेट' स्प्रेड और ब्रेक-इवन प्वाइंट का कैलकुलेशन

स्क्रीन पर 3% का बढ़िया गैप देखकर उसे पक्का प्रॉफिट मान लेना—नए आर्बिट्राजर्स के कंगाल (депозит слив) होने का सबसे बड़ा कारण है। 'ग्रॉस' स्प्रेड (Gross Spread) की कोई औकात नहीं है। हमें सिर्फ हर इंफ्रास्ट्रक्चर के कटने वाले चार्जेस के बाद मिलने वाले 'नेट' स्प्रेड (Net Spread) से मतलब होना चाहिए।

नेट रिटर्न (Net Profit) का फार्मूला

Net_Profit = (P_sell · V) - (P_buy · V) - Fee_CEX - Fee_DEX - Gas - Impact

जहाँ:

• P_sell और P_buy - ऑर्डर एग्जीक्यूशन की असली कीमतें (साइट के हेडर वाली Mid-Price नहीं, बल्कि ऑर्डर बुक की गहराई/डेप्थ के हिसाब से एवरेज कीमत)।
• V - बेस टोकन या स्टेबल्स में ट्रेड का वॉल्यूम।
• Fee_CEX - टेकर ऑर्डर के लिए एक्सचेंज की फीस (आमतौर पर 0.05%–0.1%)।
• Fee_DEX - पूल की फीस (पूल के टियर के हिसाब से 0.01%, 0.05%, 0.3% या 1%)।
• Gas - ट्रांजैक्शन को ब्लॉक में शामिल करने का खर्च (USD में कन्वर्ट किया हुआ)।
• Impact - AMM पूल के अंदर आपके खुद के वॉल्यूम की वजह से प्राइस पर पड़ने वाला असर।

सबसे बड़ा दुश्मन - DEX पर Price Impact

CEX पर अगर आपको ऑर्डर बुक में $1.00 की कीमत पर 10,000 कॉइन्स दिख रहे हैं, तो आप उन्हें ठीक $1.00 (प्लस फीस) पर ही उठाएंगे। लेकिन Constant Product (x · y = k) वाले standard DEX पर आप जो भी अगला कॉइन खरीदते हैं, वो पिछले वाले से महंगा होता जाता है।

x · y = k वाले पूल में x टोकन को y टोकन के बदले बेचने का प्राइस फार्मूला:

y_out = (y_reserve · x_in · (1 - fee)) / (x_reserve + x_in · (1 - fee))

अगर आप $100,000 की लिक्विडिटी वाले पूल में $5,000 का बड़ा ऑर्डर डालते हैं, तो आप पूल के प्राइस को सीधे ~5% हिला देते हैं। आपका 3% का नेट स्प्रेड ट्रांजैक्शन के ब्लॉक में जाने से पहले ही तुरंत 2% के नुकसान में बदल जाता है।

अलग-अलग ट्रेड वॉल्यूम पर असली स्प्रेड का हिसाब ( $50k का पूल, 2.5% ग्रॉस स्प्रेड)

निचोड़: हर पूल की लिक्विडिटी के हिसाब से ट्रेड वॉल्यूम की अपनी एक सख्त गणितीय लिमिट होती है। ज़रूरत से ज़्यादा पैसा घुसाओगे तो अपना ही गणित बिगाड़ बैठोगे।

सर्च का ऑटोमेशन: Python में बनाएं खुद का मॉनिटरिंग सिस्टम

ब्राउज़र खोलकर DexScreener के टैब्स और एक्सचेंज की ऑर्डर बुक को हाथ से रिफ्रेश करना अब बीते ज़माने की बात हो चुकी है। मैनुअल ट्रेडर किसी बॉट का इस्तेमाल ऑटो-एग्जीक्यूशन के लिए नहीं करते (वहाँ MEV बॉट्स से जीतना नामुमकिन है), बल्कि तब करते हैं जब कोई तगड़ा मौका दिखे तो Telegram या कंसोल में तुरंत साउंड/टेक्स्ट अलर्ट आ जाए।

नीचे Python 3.10+ का एक fully functional और complete कोड दिया गया है। यह स्क्रिप्ट RPC के ज़रिए PancakeSwap v2 (BNB Chain) के पूल रिज़र्व को रियल-टाइम में मॉनिटर करती है और CEX की ऑर्डर बुक (यहाँ Binance REST API का एग्ज़ांपल है, जिसे EXMON पर भी आसानी से सेट किया जा सकता है) से कंपेयर करती है। बेशक, कोड बेसिक है और इसे और बेहतर बनाया जा सकता है, लेकिन यह एकदम टकाटक काम करता है।

रिज़र्व और फीस को ध्यान में रखकर बनाया गया स्प्रेड स्कैनर कोड

import sys
import time
import requests
from web3 import Web3
# ============================================================
# CONFIG
# ============================================================
BSC_RPC = "https://bsc-dataseed1.binance.org"
POOL_ADDRESS = Web3.to_checksum_address(
   "0x16b9a82891338f9bA80E2D6970FddA79D1eb0daE"
)
BINANCE_DEPTH_URL = (
   "https://api.binance.com/api/v3/depth"
   "?symbol=BNBUSDT&limit=20"
)
TRADE_VOLUME_USD = 300.0
CEX_TAKER_FEE = 0.001
DEX_FEE = 0.0025
MIN_NET_SPREAD_PCT = 0.8
# приблизительная оценка газа за swap
ESTIMATED_GAS_COST_USD = 0.15
REQUEST_TIMEOUT = 3
# ============================================================
# WEB3
# ============================================================
w3 = Web3(Web3.HTTPProvider(BSC_RPC))
if not w3.is_connected():
   print("Ошибка подключения к BSC RPC")
   sys.exit(1)
# ============================================================
# ABI
# ============================================================
PAIR_ABI = [
   {
       "constant": True,
       "inputs": [],
       "name": "getReserves",
       "outputs": [
           {"name": "_reserve0", "type": "uint112"},
           {"name": "_reserve1", "type": "uint112"},
           {"name": "_blockTimestampLast", "type": "uint32"},
       ],
       "stateMutability": "view",
       "type": "function",
   },
   {
       "constant": True,
       "inputs": [],
       "name": "token0",
       "outputs": [{"name": "", "type": "address"}],
       "stateMutability": "view",
       "type": "function",
   },
   {
       "constant": True,
       "inputs": [],
       "name": "token1",
       "outputs": [{"name": "", "type": "address"}],
       "stateMutability": "view",
       "type": "function",
   },
]
pair = w3.eth.contract(
   address=POOL_ADDRESS,
   abi=PAIR_ABI
)
# ============================================================
# KNOWN TOKENS
# ============================================================
WBNB = Web3.to_checksum_address(
   "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"
)
USDT = Web3.to_checksum_address(
   "0x55d398326f99059fF775485246999027B3197955"
)
# ============================================================
# VERIFY PAIR
# ============================================================
try:
   token0 = Web3.to_checksum_address(
       pair.functions.token0().call()
   )
   token1 = Web3.to_checksum_address(
       pair.functions.token1().call()
   )
except Exception as e:
   print("Ошибка чтения token0/token1")
   print(e)
   sys.exit(1)
PAIR_LAYOUT = None
if token0 == WBNB and token1 == USDT:
   PAIR_LAYOUT = "WBNB_USDT"
elif token0 == USDT and token1 == WBNB:
   PAIR_LAYOUT = "USDT_WBNB"
else:
   print("Пул не является парой WBNB/USDT")
   print("token0 =", token0)
   print("token1 =", token1)
   sys.exit(1)
print("Pair verified:")
print("token0 =", token0)
print("token1 =", token1)
# ============================================================
# BINANCE
# ============================================================
def get_orderbook():
   try:
       response = requests.get(
           BINANCE_DEPTH_URL,
           timeout=REQUEST_TIMEOUT
       )
       response.raise_for_status()
       data = response.json()
       if "bids" not in data:
           return None
       if "asks" not in data:
           return None
       return data
   except Exception:
       return None
def calculate_execution_buy_price(
   asks,
   target_usd
):
   """
   Покупка BNB за USDT.
   Возвращает:
       avg_price,
       received_bnb
   """
   spent_usd = 0.0
   received_bnb = 0.0
   for price_str, qty_str in asks:
       price = float(price_str)
       qty = float(qty_str)
       level_usd = price * qty
       if spent_usd + level_usd >= target_usd:
           remaining_usd = target_usd - spent_usd
           partial_qty = remaining_usd / price
           received_bnb += partial_qty
           spent_usd += remaining_usd
           break
       received_bnb += qty
       spent_usd += level_usd
   if spent_usd < target_usd:
       return None, None
   avg_price = spent_usd / received_bnb
   return avg_price, received_bnb
def calculate_execution_sell_price(
   bids,
   sell_bnb
):
   """
   Продажа BNB в USDT.
   Возвращает:
       avg_price,
       received_usdt
   """
   remaining_bnb = sell_bnb
   received_usdt = 0.0
   sold_bnb = 0.0
   for price_str, qty_str in bids:
       price = float(price_str)
       qty = float(qty_str)
       take_qty = min(
           remaining_bnb,
           qty
       )
       received_usdt += take_qty * price
       sold_bnb += take_qty
       remaining_bnb -= take_qty
       if remaining_bnb <= 0:
           break
   if remaining_bnb > 0:
       return None, None
   avg_price = received_usdt / sold_bnb
   return avg_price, received_usdt
# ============================================================
# DEX
# ============================================================
def get_reserves():
   try:
       reserves = (
           pair.functions
           .getReserves()
           .call()
       )
       raw0 = reserves[0]
       raw1 = reserves[1]
       if PAIR_LAYOUT == "WBNB_USDT":
           reserve_bnb = raw0 / 1e18
           reserve_usdt = raw1 / 1e18
       else:
           reserve_usdt = raw0 / 1e18
           reserve_bnb = raw1 / 1e18
       return (
           reserve_bnb,
           reserve_usdt
       )
   except Exception:
       return None, None
def amm_out(
   amount_in,
   reserve_in,
   reserve_out
):
   if (
       amount_in <= 0
       or reserve_in <= 0
       or reserve_out <= 0
   ):
       return 0.0
   amount_in_fee = (
       amount_in
       * (1 - DEX_FEE)
   )
   numerator = (
       amount_in_fee
       * reserve_out
   )
   denominator = (
       reserve_in
       + amount_in_fee
   )
   return numerator / denominator
# ============================================================
# MONITOR
# ============================================================
def monitor():
   print()
   print("DEX/CEX Arbitrage Monitor Started")
   print("-" * 80)
   while True:
       book = get_orderbook()
       if book is None:
           time.sleep(1)
           continue
       reserve_bnb, reserve_usdt = (
           get_reserves()
       )
       if (
           reserve_bnb is None
           or reserve_usdt is None
       ):
           time.sleep(1)
           continue
       bids = book["bids"]
       asks = book["asks"]
       # ====================================================
       # SCENARIO A
       # BUY ON DEX
       # SELL ON CEX
       # ====================================================
       bnb_from_dex = amm_out(
           TRADE_VOLUME_USD,
           reserve_usdt,
           reserve_bnb
       )
       if bnb_from_dex <= 0:
           time.sleep(1)
           continue
       sell_price, usdt_received = (
           calculate_execution_sell_price(
               bids,
               bnb_from_dex
           )
       )
       if usdt_received is None:
           time.sleep(1)
           continue
       usdt_received *= (
           1 - CEX_TAKER_FEE
       )
       usdt_received -= (
           ESTIMATED_GAS_COST_USD
       )
       spread_a = (
           (usdt_received - TRADE_VOLUME_USD)
           / TRADE_VOLUME_USD
       ) * 100
       # ====================================================
       # SCENARIO B
       # BUY ON CEX
       # SELL ON DEX
       # ====================================================
       buy_price, bought_bnb = (
           calculate_execution_buy_price(
               asks,
               TRADE_VOLUME_USD
           )
       )
       if bought_bnb is None:
           time.sleep(1)
           continue
       bought_bnb *= (
           1 - CEX_TAKER_FEE
       )
       usdt_from_dex = amm_out(
           bought_bnb,
           reserve_bnb,
           reserve_usdt
       )
       usdt_from_dex -= (
           ESTIMATED_GAS_COST_USD
       )
       spread_b = (
           (usdt_from_dex - TRADE_VOLUME_USD)
           / TRADE_VOLUME_USD
       ) * 100
       dex_price = (
           reserve_usdt
           / reserve_bnb
       )
       sys.stdout.write(
           "\r"
           f"DEX={dex_price:.2f} | "
           f"A:{spread_a:+.2f}% | "
           f"B:{spread_b:+.2f}%"
       )
       sys.stdout.flush()
       if spread_a >= MIN_NET_SPREAD_PCT:
           print(
               "\n"
               f"[SIGNAL] "
               f"BUY DEX -> SELL CEX "
               f"({spread_a:.2f}%)"
           )
       elif spread_b >= MIN_NET_SPREAD_PCT:
           print(
               "\n"
               f"[SIGNAL] "
               f"BUY CEX -> SELL DEX "
               f"({spread_b:.2f}%)"
           )
       time.sleep(1.5)
# ============================================================
# ENTRY
# ============================================================
if __name__ == "__main__":
   try:
       monitor()
   except KeyboardInterrupt:
       print("\nStopped.")

यह स्क्रिप्ट असली स्लिपेज (Slippage) को कैलकुलेट करती है, क्योंकि यह डिफ़ॉल्ट रेट के बजाय पूल के मैथ मॉडल के ज़रिए आपके $300 के वॉल्यूम को टेस्ट करती है।

मैनुअल एग्जीक्यूशन प्रोटोकॉल: सैंडविच बॉट्स का शिकार बनने से कैसे बचें

अलग-अलग प्लेटफॉर्म्स पर दो बटन क्लिक करना सुनने में बहुत आसान लगता है। असलियत में, 80% मैनुअल ट्रेडर्स अपनी ट्रांजैक्शन पब्लिक मेम्पूल में भेजते ही अपना प्रॉफिट गंवा बैठते हैं।

जैसे ही आपकी DEX बाइंग ट्रांजैक्शन Ethereum, BNB Chain या Arbitrum के पब्लिक मेम्पूल में पहुँचती है, MEV (Maximum Extractable Value) बॉट्स तुरंत उस पर झपट पड़ते हैं। अगर आपका स्लिपेज टॉलरेंस (Slippage Tolerance) 0.5% से ऊपर सेट है, तो बॉट तुरंत सैंडविच अटैक (Sandwich Attack) लॉन्च कर देता है:

• बोट आपकी ट्रांजैक्शन से ठीक पहले टोकन खरीद लेता है, जिससे कीमत ऊपर भाग जाती है (Frontrun)।
• आपकी ट्रांजैक्शन आपके स्लिपेज लिमिट की बिल्कुल आखिरी सीमा पर सबसे खराब कीमत पर एग्जीक्यूट होती है।
• बोट प्रॉफिट सुरक्षित करने के लिए आपके तुरंत बाद उस टोकन को बेच देता है (Backrun)।

नतीजा क्या होता है? आपको टोकन चढ़े हुए भाव पर मिलता है, और पूरा स्प्रेड MEV सर्चिया ले जाता है।

सुरक्षित ट्रांजैक्शन एग्जीक्यूशन पाइपलाइन

बॉट्स को खाना खिलाए बिना खुद से स्प्रेड लूटने के लिए, आपको अपनी ट्रेडिंग इस सेटअप के हिसाब से करनी होगी:

• प्राइवेट RPC नोट्स (MEV-Blocker / Flashbots)। MetaMask की डिफ़ॉल्ट नेटवर्क सेटिंग भूल जाइए। DEX पर होने वाली हर ट्रांजैक्शन सिर्फ प्राइवेट रिले के जरिए जानी चाहिए जो पब्लिक मेम्पूल को बायपास करके सीधे ब्लॉक वैलिडेटर को ट्रांजैक्शन भेजते हैं。
  Ethereum के लिए: https://rpc.mevblocker.io या https://rpc.flashbots.net
  BNB Chain / Polygon / Arbitrum के लिए: QuickNode की MEV-Protection सर्विस या BloXroute जैसी सर्विसेज का इस्तेमाल करें।
• सख्त Slippage Limit। Uniswap या 1inch इंटरफेस पर डिफ़ॉल्ट 1% या 2% की सेटिंग को भूल जाइए। आर्बिट्रेज ट्रेड के लिए अधिकतम स्वीकार्य स्लिपेज सिर्फ 0.1%–0.3% होना चाहिए। ब्लॉक में शामिल होने से ठीक पहले अगर कीमत भाग जाए, तो घाटे में ट्रेड एग्जीक्यूट होने के बजाय ट्रांजैक्शन फेल (revert) हो जानी चाहिए।
• Gas Fee ऑप्टिमाइजेशन। अपने Web3 वॉलेट में फीस सेटिंग को मैनुअल मोड (Advanced Gas Controls) पर सेट करें। अगले ब्लॉक की शुरुआत में अपनी जगह पक्की करने के लिए Max Priority Fee (वैलिडेटर टिप) को नेटवर्क की मौजूदा मीडियन वैल्यू से थोड़ा ऊपर सेट करें। L2 नेटवर्क्स (Arbitrum, Base, OP) पर L1 डेटा फीस पर नजर रखना बेहद जरूरी है—जब एथेरियम पर लोड ज्यादा होता है, तो L2 पर ट्रांजैक्शन भेजना सामान्य से 5 गुना तक महंगा पड़ सकता है।

एडवांस्ड तकनीक: डेल्टा-नट्रल आर्बिट्रेज “DEX Spot vs CEX Futures”

स्प्रेड आने का इंतज़ार करते हुए दोनों तरफ altcoin होल्ड करके रखना अपने आप में एसेट प्राइस गिरने का रिस्क (Market Price Risk) मोल लेना है। अगर सिक्के 15% क्रैश हो गए, तो आपका 2% का फिक्स स्प्रेड पोर्टफोलियो का नुकसान नहीं भर पाएगा।

EXMON Academy में इस्तेमाल की जाने वाली एडवांस्ड मेथोडोलॉजी फ्यूचर्स के जरिए डेल्टा-नट्रल स्प्रेड ट्रेडिंग है।

शॉर्ट हेज के जरिए काम करने का तरीका

CEX पर स्पॉट एसेट खरीदने के बजाय, आप वहाँ 1x लेवरेज के साथ फ्यूचर्स में शॉर्ट पोजीशन खोल लेते हैं।

एग्जीक्यूशन एल्गोरिथम:

• DEX पर कीमत गिरती है: टोकन लुढ़क कर $0.95 पर आ जाता है, जबकि CEX पर फ्यूचर्स और स्पॉट अभी भी $0.95 पर टिके रहते हैं। (स्प्रेड 5.2%)।
• आप DEX पर $0.95 में स्पॉट खरीद लेते हैं।
• उसी समय, CEX पर $1.00 की कीमत पर फ्यूचर्स शॉर्ट पोजीशन खोल लेते हैं।
• आपका डेल्टा तुरंत जीरो हो जाता है: मार्केट चाहे किसी भी दिशा में जाए, आपके पोर्टफोलियो की कुल वैल्यू पर कोई असर नहीं पड़ता।
• जब DEX पर कीमत CEX के बराबर आ जाती है (मान लीजिए दोनों प्लेटफॉर्म्स $0.98 पर सेटल हो जाते हैं), तो आप दोनों पोजीशन बंद कर देते हैं:
  • DEX पर $0.98 में स्पॉट बेच दें (प्रोफिट: +$0.03 प्रति सिक्का)।
  • CEX पर $0.98 पर शॉर्ट पोजीशन बंद कर दें (प्रोफिट: +$0.02 प्रति सिक्का)।

कुल शुद्ध मुनाफा: प्रति सिक्का $0.05 (इस्तेमाल किए गए फंड का 5%) वो भी टोकन के गिरने के बिना किसी रिस्क के।

बोनस फायदा: अगर CEX पर फ्यूचर्स कॉन्टैंगो में ट्रेड हो रहे हैं (फ्यूचर्स की कीमत स्पॉट से ज्यादा है), तो आप हर सेटलमेंट घंटे पॉजिटिव Funding Rate (फंडिंग रेट) भी कमाते हैं।

छिपे हुए खतरे और जरूरी रिस्क

अगर कोई स्ट्रैटेजी बहुत परफेक्ट लग रही है, तो इसका मतलब है कि आपने उसकी छुपी हुई कमजोरियां नहीं देखी हैं। मैनुअल स्प्रेड ट्रेडिंग में तकनीकी रूप से कई छुपी हुई 'माइंस' होती हैं।

1. बिल्ट-इन टैक्स वाले टोकन्स (Transfer Tax / Reflection Tokens)

कुछ ERC-20 / BEP-20 टोकन्स अपने स्मार्ट कॉन्ट्रैक्ट में ही ट्रांसफर फीस जोड़कर रखते हैं (जैसे बर्न या मार्केटिंग वॉलेट के लिए 2%–5% की कटौती)।

اگر آپ نے ایکسپلورر یا سیکیورٹی سکینر (TokenSniffer, GoPlus) سے کانٹریکٹ کوڈ چیک نہیں کیا، تو پول سے ٹোকن نکالتے ہی آپ کو ٹোকन کی اپنی مکینیکل فیس کی وجہ سے 5% کا جھٹকা لگے گا، اوپر سے AMM فیس کا 0.3% کٹ جائے گا، اور آپ بھاری نقصان میں ٹ्रेड بند کر دیں گے۔

2. Uniswap v3 में वर्चुअल लिक्विडिटी का खिसकना (Concentrated Liquidity Trap)

Uniswap v2 में लिक्विडिटी जीरो से इन्फिनिटी तक फैली होती है। v3 में लिक्विडिटी चुनिंदा प्राइस रेंज (Ticks) में सिमटी होती है।

अगर स्प्रेड इसलिए पैदा हुआ है क्योंकि कीमत मुख्य मार्केट मेकर की रेंज से बाहर निकल गई है, तो आंखों से देखने पर प्राइस का अंतर बहुत बड़ा (10%–20% तक) लग सकता है। लेकिन उस समय मौजूदा टिक पर लिक्विडिटी का वॉल्यूम शायद सिर्फ $15 ही हो। वहाँ ट्रेड मारने की कोशिश करते ही कीमत आपके खिलाफ दर्जनों प्रतिशत खिसक जाएगी।

3. लिक्विडिटी का असंतुलन और "फंसा हुआ फंड" (Inventory Risk)

लगातार 5 बार एक ही दिशा में स्प्रेड पकड़ने के बाद (जैसे: DEX पर खरीदना -> CEX पर बेचना), CEX पर आपका USDT खत्म हो जाएगा और आपका Web3 वॉलेट आल्टकॉइन्स से भर जाएगा।

रीबैलेंसिंग में समय लगता है और फीस भी लगती है। अगर मार्केट तेज ट्रेंड में निकल गया, तो आप पोजीशन के एक ही पैर पर फंस कर रह जाएंगे। रिस्क रूल: किसी भी प्लेटफॉर्म पर बैलेंस का असंतुलन कभी भी 70/30 के रेश्यो से ज्यादा नहीं होना चाहिए।

बटन दबाने से पहले ट्रेडर की चेकलिस्ट

इस चेकलिस्ट को अपने काम करने वाले मॉनिटर के सामने चिपका लें। ट्रेड में एंट्री तभी लें जब ये सभी 5 शर्तें पूरी होती हों:

• MEV प्रोटेक्शन ऑन है: वॉलेट में प्राइवेट RPC नोड (MEV-Blocker / Flashbots) चुना हुआ है।
• पूल की गहराई जांची गई है: ट्रेड का साइज DEX पर कुल पूल रिजर्व के 1%–2% से ज्यादा नहीं है (Price Impact < 0.3%)।
• शुद्ध स्प्रेड कन्फर्म है: कीमतों का अंतर CEX + DEX + Gas की कुल फीस को कम से कम 2.5 गुना कवर कर रहा है।
• स्मार्ट कॉन्ट्रैक्ट साफ है: टोकन में कोई छुपी हुई ट्रांसफर फीस नहीं है (Transfer Fee = 0%)।
• पूंजी बंटी हुई है: बिना किसी ट्रांसफर या ब्रिज का इंतजार किए तुरंत एग्जीक्यूशन के लिए CEX और DEX दोनों पर ट्रेडिंग पेयर की दोनों मुद्राओं में पर्याप्त बैलेंस मौजूद है।

डिसेंट्रलाइज्ड और सेंट्रलाइज्ड प्लेटफॉर्म्स के बीच स्प्रेड ट्रेडिंग पूरी तरह से गणित का खेल है। यहाँ वो नहीं जीतता जो ट्रेंड की दिशा का अंदाजा लगाता है, बल्कि वो जीतता है जो फीस का हिसाब लगाना, इंफ्रास्ट्रक्चर को कंट्रोल करना और अपनी मार्केट एनोमली (विसंगति) का इंतजार करना सबसे अच्छे से जानता है।