DeFi Liquidation Bots: ऐसे ढूँढें Whale का Liquidation Node

डिसेंट्रलाइज्ड फाइनेंस (DeFi) की दुनिया को अक्सर एक डिजिटल जंगल कहा जाता है, और सच मानिए, यह बात 100% सटीक है। जब आम रिटेल ट्रेडर्स चार्ट्स को देखकर ट्रेंड का अंदाजा लगाने में सिर खपा रहे होते हैं, तब असली प्रो प्लेयर्स — यानी MEV सर्चर्स (Maximal Extractable Value) और लिक्विडेशन बॉट ऑपरेटर्स — सीधे ब्लॉकचेन को खंगाल रहे होते हैं ताकि दूसरों की रणनीतिक गलतियों को पकड़ सकें।

खेल तब शुरू होता है जब कोई बड़ा प्लेयर ("व्हेल") किसी लेंडिंग प्लेटफॉर्म (जैसे Aave, Compound, Spark, Morpho) पर अपनी भारी-भरकम क्रिप्टो एसेट को गिरवी रखकर मोटा लोन उठाता है और मार्केट अचानक उसके खिलाफ चला जाता है। जैसे ही उसकी पोजीशन फोर्स-क्लोज होने की कगार पर पहुंचती है, मार्केट में एक ऐसी इनएफिशिएंसी (कमी) पैदा होती है, जहां से छप्परफाड़ कमाई की जा सकती है।

इस आर्टिकल में हम बारीकी से समझेंगे कि ऐसी क्रिटिकल पोजीशन्स को ट्रैक करने का पूरा सिस्टम कैसे काम करता है, लिक्विडेशन से महज 1% की दूरी पर बैठी "व्हेल्स" को कैसे स्पॉट किया जाए, और टेक्निकल व स्ट्रैटेजिक लेवल पर इससे मोटा प्रॉफिट कैसे निकाला जाए।

DeFi लेंडिंग की इनसाइड स्टोरी: आखिर क्यों होते हैं लिक्विडेशन

मार्केट की इस कमजोरी का फायदा उठाने के लिए आपको लेंडिंग प्रोटोकॉल्स (Lending Protocols) के पीछे की पूरी मैथ को रटना होगा। सेंट्रलाइज्ड एक्सचेंजों (CEX) के उलट, जहां लिक्विडेशन का पूरा काम एक्सचेंज का खुद का इंटरनल इंजन संभालता है, DeFi में यह पूरा प्रोसेस बाहरी प्लेयर्स — जिन्हें हम लिक्विडेटर्स कहते हैं — को आउटसोर्स कर दिया जाता है।

प्रोटोकॉल खुद से किसी पोजीशन को बंद नहीं कर सकता क्योंकि उसमें कोई इन-बिल्ट ट्रिगर नहीं होता। इसकी जगह, वह एक तगड़ा इकोनॉमिक इंसेंटिव (गिरवी रखे एसेट को सस्ते में खरीदने का डिस्काउंट, जो आमतौर पर 5-10% होता है) ऑफर करता है। इससे नेटवर्क का कोई भी ऑपरेटर आकर उधारकर्ता का कर्ज चुका सकता है और उसका कोलैटरल (जमानत) सस्ते में अपने नाम कर सकता है।

सबसे बड़ा गेम-चेंजर: हेल्थ फैक्टर (HF)

किसी भी लेंडिंग पोजीशन की सेफ्टी को मापने के लिए हेल्थ फैक्टर (Health Factor) का इस्तेमाल किया जाता है। ज्यादातर EVM-कम्पैटिबल प्रोटोकॉल्स (जैसे Aave v3) में इसका फार्मूला कुछ ऐसा दिखता है:

यहाँ:

• Collateral_i - बेस करेंसी (जैसे ETH या USD) में गिरवी रखे गए एसेट i की कुल वैल्यू।
• LiquidationThreshold_i (लिक्विडेशन सीमा) - प्रोटोकॉल द्वारा उस एसेट के लिए तय किया गया मैक्सिमम डेट-टू-कोलैटरल रेशियो (जैसे 85%)।
• Debt_j - लिए गए लोन j की कुल वैल्यू, जिसमें जमा हुआ ब्याज (इंटरेस्ट) भी शामिल है।

टर्निंग पॉइंट: जब तक HF > 1 है, पोजीशन पूरी तरह से सेफ है। लेकिन जैसे ही HF < 1 होता है, वह पोजीशन पब्लिक लिक्विडेशन के लिए ओपन हो जाती है और कोई भी बॉट उसे लिक्विडेट कर सकता है।

"लिक्विडेशन से 1% दूर" होने का क्या मतलब है?

यह किसी पोजीशन की वह नाजुक हालत है जब उसका HF 1.0001 से 1.01 के बेहद डेंजर जोन में आ जाता है। यहाँ से गिरवी रखे एसेट की कीमत में जरा सी भी गिरावट (या उधार लिए एसेट की कीमत में थोड़ी सी बढ़त) उस पोजीशन को तुरंत बॉट्स का "आसान शिकार" बना देती है।

'डंप से कमाई' की स्ट्रैटेजी: दो बड़े गेम प्लान

ज्यादातर लोग सोचते हैं कि लिक्विडेटर की कमाई सिर्फ प्रोटोकॉल से मिलने वाले बोनस तक ही सीमित है। लेकिन जब बात करोड़ों डॉलर वाली व्हेल्स की पोजीशन्स की हो, तो बैकएंड पर कमाई के और भी बड़े और शातिर रास्ते खुल जाते हैं।

सिनेरियो A: फ्लैश लोन के जरिए क्लासिक लिक्विडेशन

आपको एक ऐसी पोजीशन मिलती है जिसका HF < 1 हो चुका है। अब किसी का $10,000,000 का कर्ज चुकाने के लिए आपके पास अपनी जेब में तो पैसा है नहीं। ऐसे में आप फ्लैश लोन (Flash Loan) का दांव खेलते हैं:

1. आप बिना किसी कोलैटरल के, एक ही ट्रांजैक्शन के अंदर Uniswap या Aave से $10 मिलियन DAI का लोन उठाते हैं।
2. इस फंड से आप लेंडिंग प्रोटोकॉल में जाकर उस व्हेल का पूरा कर्ज चुकता कर देते हैं।
3. बदले में आपको उसका कोलैटरल (मान लीजिए ETH) 5% के डिस्काउंट पर मिल जाता है (यानी आपको $10.5 मिलियन की वैल्यू का ETH मिल गया)।
4. आप बिना पलक झपकाए उस ETH को DEX पर बेचते हैं, फ्लैश लोन के $10 मिलियन DAI + उसकी फीस वापस करते हैं।
5. गैस फीस काटने के बाद बचा हुआ पूरा नेट प्रॉफिट (~$490,000) सीधा आपके वॉलेट में आ जाता है।

सिनेरियो B: टारगेटेड शॉर्ट और मार्केट को धक्का देना (Whale Hunting)

यह काफी आक्रामक और एडवांस स्ट्रैटेजी है, जिसके लिए मार्केट लिक्विडिटी की गहरी समझ होना जरूरी है:

1. आपको एक ऐसी व्हेल दिखती है जिसका HF 1.005 है (यानी बर्बादी से सिर्फ 1% दूर)। उसका कोलैटरल $50,000 WBTC है और लोन USDT में है।
2. आप पूरा हिसाब-किताब लगाते हैं कि WBTC का भाव कितना गिरने पर उसका HF सीधा 1 पर आ जाएगा। मान लेते हैं कि इसके लिए कीमत को सिर्फ $150 गिरना है।
3. आप फ्यूचर्स मार्केट या डेरिवेटिव्स DEX पर जाकर भारी लेवरेज के साथ WBTC की एक बड़ी शॉर्ट (Short) पोजीशन खोल देते हैं।
4. अब जैसे ही स्पॉट मार्केट में लिक्विडिटी थोड़ी कम होती है (ऑर्डर बुक खाली होती है), आप या मार्केट के दूसरे प्लेयर्स स्पॉट मार्केट में भारी मात्रा में WBTC डंप कर देते हैं, जिससे एक सेकंड के लिए प्राइस अचानक क्रैश (Flash Crash) हो जाता है।
5. प्राइस लिक्विडेशन ट्रिगर को छू जाता है। लिक्विडेशन बॉट्स (या आपका अपना स्क्रिप्ट) उस व्हेल को ताबड़तोड़ लिक्विडेट करना शुरू कर देते हैं। लिक्विडेशन के इस प्रोसेस में कर्ज वसूलने के लिए भारी मात्रा में WBTC को जबरन मार्केट में बेचा जाता है, जिससे प्राइस और तेजी से नीचे गिरता है (कैस्केड इफेक्ट)।
6. इस जबरन या प्री-प्लान्ड डंप के बिल्कुल बॉटम पर आपकी शॉर्ट पोजीशन का टेक-प्रॉफिट (Take-Profit) हिट हो जाता है और आप तगड़ा मुनाफा समेट लेते हैं।

"घायल व्हेल्स" को खोजने के हथियार

Etherscan पर जाकर मैन्युअली ब्लॉकचेन को ट्रैक करना नामुमकिन है। इसके लिए प्रो प्लेयर्स तीन लेवल के टूल्स का इस्तेमाल करते हैं: रेडीमेड डैशबोर्ड्स, इंफ्रास्ट्रक्चर API और खुद के कस्टमाइज्ड नोड पार्सर्स।

1. रेडीमेड एनालिटिक्स प्लेटफॉर्म्स (शुरुआत के लिए बेस्ट)

• DeFi Saver (Loan Shifter / Simulation सेक्शन): इसके जरिए आप बड़े-बड़े प्रोटोकॉल्स में चल रही मोटी पोजीशन्स को आसानी से विज़ुअलाइज़ कर सकते हैं।
• Debank / Arkham Intelligence: इनका इस्तेमाल खास वॉलेट एड्रेस की वॉचलिस्ट (Watchlists) बनाने के लिए किया जाता है। जैसे ही आपको किसी टोकन के टॉप होल्डर्स में कोई बड़ा कर्जदार दिखता है, आप उसके एड्रेस पर अलर्ट सेट कर देते हैं।
• Dune Analytics: यहाँ कई पब्लिक डैशबोर्ड्स मिल जाएंगे जो बड़े उधारकर्ताओं के हेल्थ फैक्टर को रियल-टाइम में ट्रैक करते हैं। (सर्च टैग्स: Aave v3 liquidation thresholds, Compound positions monitoring)।

2. स्पेशलाइज्ड API (ऑटोमेशन के लिए)

बिना किसी झंझट के और बिना खुद का खर्चीला आर्काइव नोड सेटअप किए फिल्टर डेटा पाने का सबसे सॉलिड तरीका है — सीधे प्रोटोकॉल्स की ऑफिशियल API का यूज करना।

उदाहरण के लिए, Aave का एक ओपन GraphQL एंडपॉइंट (The Graph) है, जिसकी मदद से आप एक ही बार में सभी उधारकर्ताओं का पूरा कच्चा-चिट्ठा निकाल सकते हैं।

प्रैक्टिकल गाइड: क्रिटिकल पोजीशन्स के लिए पार्सर कोड लिखना

अब आते हैं टेक्निकल पार्ट पर। लिक्विडेशन से सिर्फ 1% की दूरी पर बैठे एड्रेस को खोजने के लिए हमें एक ऐसा स्क्रिप्ट लिखना होगा जो सीधे संबंधित प्रोटोकॉल के Pool या DataProvider स्मार्ट कॉन्ट्रैक्ट से डेटा निकाल सके।

नीचे Python और web3.py लाइब्रेरी का उपयोग करके एक स्क्रिप्ट का उदाहरण दिया गया है। यह स्क्रिप्ट Arbitrum ब्लॉकचेन (लिक्विडेशन के लिए बेस्ट क्योंकि यहाँ फीस कम और स्पीड सुपरफास्ट है) पर मौजूद Aave Protocol Data Provider कॉन्ट्रैक्ट को हिट करती है, यूजर का डेटा निकालती है और कैलकुलेट करती है कि वह लिक्विडेशन के कितने करीब है।

import os
from web3 import Web3
# किसी फास्ट RPC-नोड (जैसे Alchemy या QuickNode) से कनेक्शन सेटअप करें
RPC_URL = "https://arb-mainnet.g.alchemy.com/v2/YOUR_API_KEY"
w3 = Web3(Web3.HTTPProvider(RPC_URL))
if not w3.is_connected():
    raise Exception("ब्लॉकचेन से कनेक्ट करने में विफल")
# Arbitrum पर Aave v3 Pool कॉन्ट्रैक्ट का एड्रेस
AAVE_POOL_ADDRESS = "0x794a61358D6845594F94dc1DB02A252b5b4814aD"
# मिनिमल ABI, जिसमें सिर्फ getUserAccountData फंक्शन शामिल है
AAVE_POOL_ABI = [
    {
        "inputs": [{"internalType": "address", "name": "user", "type": "address"}],
        "name": "getUserAccountData",
        "outputs": [
            {"internalType": "uint256", "name": "totalCollateralBase", "type": "uint256"},
            {"internalType": "uint256", "name": "totalDebtBase", "type": "uint256"},
            {"internalType": "uint256", "name": "availableBorrowsBase", "type": "uint256"},
            {"internalType": "uint256", "name": "currentLiquidationThreshold", "type": "uint256"},
            {"internalType": "uint256", "name": "ltv", "type": "uint256"},
            {"internalType": "uint256", "name": "healthFactor", "type": "uint256"}
        ],
        "stateMutability": "view",
        "type": "function"
    }
]
pool_contract = w3.eth.contract(address=AAVE_POOL_ADDRESS, abi=AAVE_POOL_ABI)
def check_whale_position(user_address):
    try:
        # स्मार्ट कॉन्ट्रैक्ट से अकाउंट का डेटा फेच करें
        data = pool_contract.functions.getUserAccountData(w3.to_checksum_address(user_address)).call()
        
        # मिलने वाला डेटा 18 डेसिमल्स की सटीकता के साथ होता है (Aave की बेस करेंसी में)
        collateral = data[0] / 1e8  # v3 की बेस करेंसी के आधार पर (आमतौर पर 8 डेसिमल्स के साथ USD)
        debt = data[1] / 1e8
        hf = data[5] / 1e18 # हेल्थ फैक्टर 18 डेसिमल प्लेसेज के साथ आता है
        
        # सिर्फ बड़े प्लेयर्स को फिल्टर करें (कोलैटरल > $500,000)
        if collateral > 500000:
            print(f"एड्रेस: {user_address}")
            print(f"  कोलैटरल: ${collateral:,.2f} | लोन: ${debt:,.2f}")
            print(f"  हेल्थ फैक्टर: {hf:.4f}")
            
            # चेक करें कि क्या पोजीशन 1% के क्रिटिकल जोन में है
            # चूंकि लिक्विडेशन HF <= 1.0 पर ट्रिगर होता है, इसलिए डेंजर ज़ोन 1.0000 से 1.0100 के बीच है
            if 1.0000 < hf <= 1.0100:
                print(f"⚠️ क्रिटिकल स्टेटस: व्हेल लिक्विडेशन से सिर्फ 1% दूर! कोलैटरल डंप होने का खतरा।")
                # यहाँ आप टेलीग्राम अलर्ट भेजने या अपने लिक्विडेशन बॉट को ट्रिगर करने का कोड जोड़ सकते हैं
            print("-" * 50)
            
    except Exception as e:
        print(f"एड्रेस {user_address} को चेक करने में एरर: {e}")
# टेस्ट के लिए किसी व्हेल का एड्रेस यहाँ डालें (इसे अपनी लिस्ट के लाइव एड्रेस से बदलें)
whale_target = "0x..." 
check_whale_position(whale_target)

स्कैन करने के लिए एड्रेसों का डेटाबेस कहां से लाएं?

ऊपर दिया गया स्क्रिप्ट सिर्फ एक सिंगल एड्रेस को चेक करता है। लेकिन एक रियल-टाइम वर्किंग राडार बनाने के लिए आपको लगातार नए एड्रेसों की जरूरत होगी। प्रोफेशनल बॉट्स इस डेटा को ऐसे कलेक्ट करते हैं:

• हिस्टोरिकल इवेंट्स की पार्सिंग (Events): बॉट कॉन्ट्रैक्ट के डिप्लॉय होने के समय से लेकर अब तक के पूरे ब्लॉकचेन डेटा को एक बार स्कैन करता है और उन सभी एड्रेसों को निकाल लेता है जिन्होंने कभी भी Supply, Borrow, या CollateralSwitch जैसे इवेंट्स को ट्रिगर किया हो।
• लाइव लॉग्स का सबस्क्रिप्शन: स्क्रिप्ट WebSockets (w3.eth.subscribe('logs', ...)) के जरिए नए ब्लॉक्स पर नजर रखता है, ताकि पूल के साथ इंटरैक्ट करने वाले हर नए एड्रेस को तुरंत पकड़ा जा सके। सभी यूनिक एड्रेसों को लोकल डेटाबेस (जैसे MariaDB/PostgreSQL) में सेव कर लिया जाता है।
• लगातार मॉनिटरिंग (Polling): एक बैकएंड वर्कर डेटाबेस में मौजूद सभी एड्रेसों पर लगातार लूप चलाता है और बारी-बारी से उनके getUserAccountData को अपडेट करता रहता है।

"शिकार" की एनाटॉमी: एकदम सटीक ट्रिगर पॉइंट कैसे कैलकुलेट करें

किसी "घायल व्हेल" की पोजीशन का फायदा उठाने के लिए सिर्फ उसका मौजूदा Health Factor जान लेना काफी नहीं है। एक प्रोफेशनल सर्चर (searcher) को प्राइस डायनेमिक्स की गहरी समझ होनी चाहिए। हमें उस कोलैटरल एसेट (collateral asset) की वो सटीक कीमत पता करनी होगी, जिस पर पहुंचते ही पोजीशन सीधे कतरन पर चली जाए।

चलिए इस कैलकुलेशन को थोड़ा फॉर्मलाइज करते हैं। मान लेते हैं कि हमारी व्हेल के पास एक सिंगल कोलैटरल एसेट (जैसे ETH) है और एक स्थिर कीमत वाला डेट एसेट (USDT) है। इस स्पेसिफिक प्रोटोकॉल में ETH के लिए लिक्विडेशन थ्रेशोल्ड (Liquidation Threshold यानी LT) 85% (0.85) सेट है।

क्रिटिकल कोलैटरल प्राइस (Price_crit) निकालने का फॉर्मूला कुछ इस तरह दिखता है:

कैलकुलेशन का प्रैक्टिकल उदाहरण

मार्केट में खुली एक तगड़ी पोजीशन का लाइव केस देखिए:

• कुल कोलैटरल Collateral_Amount: $10,000\ ETH$
• ETH की मौजूदा कीमत: $3,400\ USD$
• फिएट (Fiat) में कोलैटरल की वैल्यू: $34,000,000\ USD$
• मौजूदा कर्ज Debt_USD: $28,500,000\ USDT$
• लिक्विडेशन थ्रेशोल्ड LT: 85% (0.85)

सबसे पहले इस पोजीशन का मौजूदा हेल्थ फैक्टर (Health Factor) निकाल लेते हैं:

यह पोजीशन तबाही के बिल्कुल मुहाने पर है, लिक्विडेशन से सिर्फ 1.4% दूर। अब वो सटीक ETH प्राइस निकालते हैं जहां पर गेम पूरी तरह ओवर हो जाएगा:

जैसे ही प्रोटोकॉल का ओरैकल (आमतौर पर Chainlink) ऑन-चेन प्राइस अपडेट पुश करके ETH की कीमत को $3,352.94 पर टच करेगा, पोजीशन तुरंत लिक्विडेट होने के लिए अनलॉक हो जाएगी।

एक अंदर का सीक्रेट (Alpha Intel): स्मार्ट कॉन्ट्रैक्ट्स को बाइनेंस (Binance) के रियल-टाइम स्पॉट प्राइस का रत्ती भर भी अंदाजा नहीं होता। वे पूरी तरह ओरैकल्स पर टिके होते हैं। चेनलिंक ओरैकल्स ऑन-चेन प्राइस को दो ही सूरतों में अपडेट करते हैं: या तो कोई टाइमर ट्रिगर हो (जैसे हर 20 मिनट पर) या फिर ऑफ-चेन प्राइस एक तय लिमिट से ज्यादा डेविएट हो जाए (Deviation Threshold) — जैसे मेजर पेयर्स के लिए 0.5% या 1% का मूवमेंट। इस थ्रेशोल्ड को ट्रैक करके, मँझे हुए खिलाड़ी ओरैकल की ट्रांजैक्शन मेमपूल (mempool) में कन्फर्म होने से कुछ सेकेंड पहले ही लिक्विडेशन का सटीक टाइम भांप जाते हैं और बाजी मार लेते हैं।

प्रैक्टिकल "Whale Hunting" स्ट्रेटेजी: एग्जीक्यूशन का पूरा मैकेनिज्म

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

1. कैपिटल इंजीनियरिंग (Flash Loans बनाम खुद का पैसा)

अगर आप लिक्विडेशन बोनस उड़ाने का प्लान कर रहे हैं (हमारे उदाहरण में $34M पर 5% का बोनस यानी सीधे $1.7M का ग्रॉस प्रॉफिट), तो आपको कर्ज चुकता करने के लिए तुरंत $28.5M का जुगाड़ करना होगा।

इतना मोटा कैश वॉलेट में फालतू रखना कैपिटल के लिहाज से सरासर बेवकूफी है, इसलिए यहाँ Flash Loan का इस्तेमाल किया जाता है, जिसे Uniswap v3 लिक्विडिटी पूल या Aave v3 लेंडर्स से उठाया जाता है। आप एक ही एटॉमिक ट्रांजैक्शन के अंदर $28.5M का लोन लेते हैं, Aave कॉन्ट्रैक्ट पर liquidationCall फंक्शन हिट करते हैं, कोलैटरल वाला ETH जब्त करते हैं, और तुरंत उस ETH का एक हिस्सा किसी लिक्विडिटी एग्रीगेटर (1inch / Paraswap) के जरिए वापस USDT में स्वाइप कर देते हैं ताकि फ्लैश लोन को उसके मामूली ब्याज (0.05%) के साथ चुकाया जा सके। बचा हुआ ETH आपका प्योर, नेट प्रॉफिट होता है।

2. मार्केट आर्बिट्रेज और टारगेटेड शॉर्ट्स

जब व्हेल का साइज इतना बड़ा हो कि स्टैंडर्ड फ्लैश लोन पूल भी छोटे पड़ जाएं, या स्पॉट डैक्स (DEX) की लिक्विडिटी इतनी पतली हो कि बिना भारी स्लिपेज (Slippage) के कोलैटरल को स्वैप करना नामुमकिन हो, तब डेरिवेटिव मार्केट में फ्रंट-रनिंग का तगड़ा गेम शुरू होता है:

1. स्टेप 1: आप देखते हैं कि प्राइस क्रिटिकल पॉइंट 3,352.94 से महज 15-20 डॉलर की दूरी पर है।
2. स्टेप 2: किसी डिसेंट्रलाइज्ड परपेचुअल एक्सचेंज (Hyperliquid, dYdX, Vertex) या बड़े CEX पर हाई लेवरेज के साथ एक अग्रेसिव शॉर्ट पोजीशन खोल दी जाती है।
3. स्टेप 3 (कैटेलिस्ट): स्पॉट मार्केट में (उस समय जब ऑर्डर बुक सबसे ज्यादा पतली हो) एक बड़ा सेलिंग ऑर्डर फेंका जाता है। अक्सर बड़े मार्केट मेकर्स या सर्चर्ज़ का सिंडिकेट मिलकर ऐसा करते हैं ताकि एक टेंपरेरी प्राइस क्रैश (dump) लाया जा सके।
4. स्टेप 4 (कैस्केड): जैसे ही प्राइस ट्रिगर को तोड़ता है, दुनिया भर के लिक्विडेटर बॉट्स अंधाधुंध लिक्विडेशन फंक्शन्स स्पैम करना शुरू कर देते हैं। अपना प्रॉफिट लॉक करने के लिए, ये बॉट्स जब्त किए गए ETH को मार्केट ऑर्डर मारकर वापस स्टेबलकॉइन्स में डंप करने लगते हैं।
5. स्टेप 5 (प्रॉफिट बुकिंग): महज एक-दो मिनट के अंदर 10,000 ETH की अंधाधुंध बिकवाली लोकल सपोर्ट को पूरी तरह उड़ा देती है, जिससे प्राइस 2-3% और नीचे चला जाता है। आपकी शॉर्ट पोजीशन इस आर्टिफिशल या एक्सेलरेटेड पैनिक के बिल्कुल बॉटम पर जाकर मक्खन की तरह क्लोज हो जाती है।

लिक्विडेशन बॉट का आर्किटेक्चर: MEV के डार्क फॉरेस्ट में सबको कैसे पछाड़ें

अगर आप खुद का एक ऐसा बॉट लिखने की सोच रहे हैं जो सीधे इन लिक्विडेशंस को एग्जीक्यूट कर सके, तो एक बेसिक Web3 स्क्रिप्ट के भरोसे बैठना भूल जाइए। इस फील्ड में स्पीड की एक खूनी जंग चल रही है, जिसे PGA (Priority Gas Auction) और MEV-बूस्ट्स की लड़ाई कहा जाता है।

पब्लिक मेमपूल में भेजी गई कोई भी आम ट्रांजैक्शन जेनरिक फ्रंट-रनर बॉट्स की नजर में आ जाएगी। वे तुरंत आपके कॉलीडेटा (calldata) को कॉपी करेंगे, गैस फीस को 1 gwei बढ़ाएंगे और आपके मुंह से निवाला छीन ले जाएंगे।

एक प्रोडक्शन-ग्रेड MEV बॉट का टेक स्टैक:

• प्रोग्रामिंग लैंग्वेज: डेटा फेचिंग और एनालिटिक्स के लिए आमतौर पर Python/Go का यूज होता है। लेकिन एग्जीक्यूशन स्मार्ट कॉन्ट्रैक्ट (जो फ्लैश लोन रूटिंग और लिक्विडेशन कॉल संभालता है) हर हाल में Solidity / Yul में ही होना चाहिए ताकि गैस की मैक्सिमम बचत हो सके। आजकल प्रो बॉट्स के बैकएंड के लिए Rust (alloy लाइब्रेरी इकोसिस्टम) का तगड़ा ट्रेंड चल रहा है।
• ब्लॉक बिल्डर्स से डायरेक्ट कनेक्शन: प्रो प्लेयर्स पब्लिक मेमपूल को पूरी तरह बायपास कर देते हैं। वे Flashbots (MEV-Share / MEV-Boost), BeaverBuild या Titan जैसे प्राइवेट रिलेज (Relays) का इस्तेमाल करते हैं। ट्रांजैक्शन को एक "बंडल" (Bundle) बनाकर सीधे वैलिडेटर के पास भेजा जाता है। आप सीधे वैलिडेटर से सेटिंग करते हैं: "मेरी ट्रांजैक्शन को ठीक उस ओरैकल ट्रांजैक्शन के पीछे लगाओ जो ETH का प्राइस गिरा रही है, और इसके बदले मैं अपने लिक्विडेशन प्रॉफिट का 50% हिस्सा तुम्हें टिप (tip) के तौर पर दे दूंगा।"

नीचे ऐसे ही एक प्रो बॉट के कंपोनेंट्स का लॉजिकल फ्लो-चार्ट दिया गया है:

[Blockchain Node / Websocket] 
       │ (नॉन-स्टॉप नए ब्लॉक्स और मेमपूल ट्रांजैक्शंस को ट्रैक करता है)
       ▼
[Parser & DB] ────► [Health Factor Calculator] 
                         │ (अगर HF <= 1 हो तो ट्रिगर होता है)
                         ▼
                  [Flashbots / MEV Builder] ──► [Private Validator] ──► [Profit]

एक्ज़ीक्यूशन स्मार्ट कॉन्ट्रैक्ट आर्किटेक्चर (Solidity)

लिक्विडेशन को एक ही सिंगल एटॉमिक ट्रांजैक्शन में सफलतापूर्वक निपटाने के लिए, Flash Loan और लेंडिंग प्रोटोकॉल के साथ इंटरैक्शन के पूरे लॉजिक को एक कस्टम स्मार्ट कॉन्ट्रैक्ट में पैक करना ज़रूरी है। सीधे वॉलेट (EOA) से अलग-अलग ट्रांजैक्शन भेजने का तो सवाल ही नहीं उठता — कॉम्पिटिटर्स तुरंत फ्रंट-रन करके पलक झपकते ही कोलैटरल उड़ा ले जाएंगे।

नीचे Solidity ^0.8.20 पर बने स्मार्ट कॉन्ट्रैक्ट का एक प्रोडक्शन-रेडी आर्किटेक्चरल उदाहरण दिया गया है, जिसे Flash Loan मैकेनिज्म के ज़रिए Aave v3 के साथ इंटरैक्ट करने के लिए पूरी तरह ऑप्टिमाइज़ किया गया है।

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
interface IPool {
    function liquidationCall(
        address collateralAsset,
        address debtAsset,
        address user,
        uint256 debtToCover,
        bool receiveAToken
    ) external;
    function flashLoanSimple(
        address receiverAddress,
        address asset,
        uint256 amount,
        bytes calldata params,
        uint16 referralCode
    ) external;
}
interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
contract LiquidatorBot {
    address public immutable owner;
    IPool public immutable aavePool;
    modifier onlyOwner() {
        require(msg.sender == owner, "Not an owner");
        _;
    }
    constructor(address _pool) {
        owner = msg.sender;
        aavePool = IPool(_pool);
    }
    // फ्लैश लोन कॉलबैक के अंदर पैरामीटर्स पास करने के लिए स्ट्रक्चर
    struct LiquidationParams {
        address collateralAsset;
        address debtAsset;
        address userToLiquidate;
        uint256 debtToCover;
    }
    // 1. एक्सटर्नल ट्रिगर: टारगेट का पता चलते ही आपके ऑफ-चेन बैकएंड (Rust/Go/Python) द्वारा कॉल किया जाता है
    function calmedDownTrigger(
        address _collateralAsset,
        address _debtAsset,
        address _userToLiquidate,
        uint256 _debtToCover
    ) external onlyOwner {
        bytes memory params = abi.encode(
            LiquidationParams({
                collateralAsset: _collateralAsset,
                debtAsset: _debtAsset,
                userToLiquidate: _userToLiquidate,
                debtToCover: _debtToCover
            })
        );
        // व्हेल के सटीक डेट वॉल्यूम के हिसाब से Aave से फ्लैश लोन की रिक्वेस्ट करते हैं
        aavePool.flashLoanSimple(
            address(this),
            _debtAsset,
            _debtToCover,
            params,
            0
        );
    }
    // 2. Aave कॉलबैक: कॉन्ट्रैक्ट बैलेंस में फंड आते ही उसी सेम ट्रांजैक्शन के अंदर एक्ज़ीक्यूट होता है
    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,
        address initiator,
        bytes calldata params
    ) external returns (bool) {
        require(msg.sender == address(aavePool), "Invalid caller");
        
        LiquidationParams memory lParams = abi.decode(params, (LiquidationParams));
        // लिक्विडेशन प्रोसेस करने के लिए पूल को हमारे फ्लैश-बोरोड फंड्स निकालने का अप्रूवल देते हैं
        IERC20(lParams.debtAsset).approve(address(aavePool), lParams.debtToCover);
        // एक्चुअल लिक्विडेशन कॉल ट्रिगर करते हैं
        // आखिरी पैरामीटर false रखने का मतलब है कि हमें रॉ कोलैटरल चाहिए, न कि उसका aToken डेरिवेटिव
        aavePool.liquidationCall(
            lParams.collateralAsset,
            lParams.debtAsset,
            lParams.userToLiquidate,
            lParams.debtToCover,
            false
        );
        // इस स्टेज पर, कॉन्ट्रैक्ट बैलेंस में जब्त किया गया कोलैटरल (जैसे ETH) आ चुका है
        // टास्क: कोलैटरल को DEX (Uniswap/1inch) पर वापस डेट एसेट (जैसे USDT) में स्वाइप करना
        // ताकि लोन का प्रिंसिपल (amount) + फ्लैश लोन की फीस (premium) कवर हो सके
        
        uint256 totalOwed = amount + premium;
        
        // [यहाँ Uniswap v3 / 1inch Router पर swap() कॉल करने का लॉजिक आएगा]
        // स्वाइप के बाद हमारे पास debtAsset की करेंसी में >= totalOwed बैलेंस होना चाहिए
        
        // फ्लैश लोन रीपेमेंट को अप्रूव करते हैं
        IERC20(lParams.debtAsset).approve(address(aavePool), totalOwed);
        // बचे हुए शुद्ध मुनाफ़े को कॉन्ट्रैक्ट ओनर के वॉलेट में ट्रांसफर करते हैं
        uint256 profit = IERC20(lParams.debtAsset).balanceOf(address(this));
        if (profit > 0) {
            IERC20(lParams.debtAsset).transfer(owner, profit);
        }
        return true;
    }
    // कॉन्ट्रैक्ट में फंसे किसी भी टोकन को इमरजेंसी में बाहर निकालने (विथड्रॉ) का फ़ंक्शन
    function withdrawToken(address _token) external onlyOwner {
        uint256 balance = IERC20(_token).balanceOf(address(this));
        IERC20(_token).transfer(owner, balance);
    }
}

कम जाने-पहचाने सीक्रेट्स और बारीकियाँ (अल्फ़ा इन्फो)

अगर सब कुछ इतना ही सीधा-सपाट होता, तो हर कोडिंग जानने वाला बंदा हफ्ते भर में करोड़पति बन जाता। असलियत में, इस इंडस्ट्री के "घने जंगल" (dark forest) के पीछे बेहद क्रूर टेक्निकल पंगे छिपे हुए हैं।

1. «सॉफ्ट लिक्विडेशन» का चक्कर (Close Factor)

अगर किसी व्हेल की पोजीशन करोड़ों डॉलर्स की है, तो आप उसकी पूरी पोजीशन को एक बार में लिक्विडेट नहीं कर सकते। ज़्यादातर मॉडर्न प्रोटोकॉल्स में Close Factor नाम का एक पैरामीटर सेट होता है (आमतौर पर यह 50% पर कैप होता है)। इसका मतलब है कि एक सिंगल ट्रांजैक्शन में आप यूज़र का सिर्फ़ आधा कर्ज़ ही चुका सकते हैं।

अगर आपको $20,000,000 के कर्ज़ वाली कोई व्हेल मिलती है, तो आपके बॉट को मैक्सिमम $10,000,000 कवर करने का ही ट्रांजैक्शन भेजना होगा। बाकी बचे कर्ज़ का री-कैलकुलेशन होता है, जिससे हेल्थ फ़ैक्टर (HF) थोड़ा सुधर जाता है, और अगर पोजीशन फिर भी डेंजर ज़ोन में रहती है, तो आप अगले ब्लॉक में उसे दोबारा लिक्विडेट कर सकते हैं।

2. ओरैकल की सुस्ती और «भूतिया» लिक्विडेशन

बड़े खिलाड़ी अपनी पोजीशन्स को लावारिस नहीं छोड़ते। वे अक्सर ऑटोमेटेड डिसेंट्रलाइज्ड कीपर्स (जैसे Gelato network या Chainlink Automation) के ज़रिए अपनी पोजीशन्स को प्रोटेक्ट करके रखते हैं, जो HF गिरते ही तुरंत मार्जिन टॉप-अप कर देते हैं।

इसके अलावा, भयंकर वोलैटिलिटी (मार्केट क्रैश) के दौर में Ethereum नेटवर्क या L2 लेयर्स (Arbitrum, Base) पर ज़बरदस्त कंजेशन और गैस स्पाइक (Gas Spike) देखने को मिलता है। ऐसे में ऑन-चेन ओरैकल प्राइस अपडेट करने में 1-2 ब्लॉक लेट हो सकता है। कोई बॉट जो ऑफ-चेन डेरिवेटिव स्पॉट प्राइस (जैसे Binance) पर नज़र रख रहा है, वह यह सोचकर लिक्विडेशन ट्रांजैक्शन भेज देगा कि HF < 1 हो चुका है, लेकिन स्मार्ट कॉन्ट्रैक्ट लेवल पर वह ट्रांजैक्शन REVERT (फ़ेल) हो जाएगा, क्योंकि ऑन-चेन ओरैकल ने अभी तक अपनी कीमत अपडेट ही नहीं की होगी। नतीजा? आप बिना बात के फ़ेल्ड ट्रांजैक्शन पर गैस फीस के रूप में अच्छे-खासे पैसे गंवा बैठेंगे।

3. प्राइवेट RPC के ज़रिए फ्रंट-रनिंग से बचाव

जब आपका बॉट Flashbots के ज़रिए ट्रांजैक्शन बंडल भेजता है, तब आप सीधे तौर पर दूसरे सर्चर्स के साथ प्रॉफिट-शेयरिंग की रेस में लड़ रहे होते हैं। मान लीजिए आपने $10,000 का कोई लिक्विडेशन ढूंढा, लेकिन आपके कॉम्पिटिटर ने अपने बॉट को इस तरह सेट कर रखा है कि वह वैलिडेटर को रिश्वत (Gas Tip) के तौर पर मुनाफ़े का 99% हिस्सा दे देता है, तो ब्लॉक उसे मिल जाएगा — वह भले ही सिर्फ़ $100 का शुद्ध मुनाफ़ा कमाए — लेकिन आपका ट्रांजैक्शन रिजेक्ट हो जाएगा।

स्ट्रेटेजिक हैक: जिन नेटवर्क्स पर गैस फीस ना के बराबर होती है और स्पीड सुपर-फ़ास्ट होती है (Base, Arbitrum, Solana), वहाँ क्लासिक Flashbots बंडल्स अलग तरीके से काम करते हैं या उस रूप में होते ही नहीं हैं। वहाँ जीत उसी की होती है जो फिज़िकली वैलिडेटर्स के सबसे नज़दीक हो (RPC नोड तक नेटवर्क पिंग सबसे कम हो) और जो कस्टम gRPC कनेक्शंस का इस्तेमाल करके थोक के भाव में (spamming) ट्रांजैक्शन ब्लास्ट कर सके।

चेकलिस्ट: व्हेल लिक्विडेशन के इर्द-गिर्द स्ट्रेटेजी कैसे तैयार करें

अगर आप खुद का मॉनिटरिंग सिस्टम सेटअप करना चाहते हैं या लिक्विडेशन की इस पूरी चेन को मैनुअली/सेमी-ऑटोमेटेड तरीके से ट्रेड करना चाहते हैं, तो इस एल्गोरिदम को स्टेप-बाय-स्टेप फॉलो करें:

• टारगेट पूल का डेटा जुटाना: बड़े मनी मार्केट्स (Aave, Compound, Spark, Morpho, Radiant) से उधार लेने वाले वॉलेट एड्रेस स्क्रैप करने के लिए एक इंडेक्सर स्क्रिप्ट लिखें। उन एड्रेस को फ़िल्टर कर लें जिनका कोलैटरल साइज़ $1,000,000 से ऊपर है।
• ट्रिगर कैलकुलेटर: एक ऐसा मैथ मॉड्यूल तैयार करें जो ट्रैक किए जा रहे व्हील्स की करंट पोजीशन के वेट्स को उठाए और कोलैटरल की उस सटीक फ्लोर प्राइस का कैलकुलेशन करे जहाँ उनका HF ठीक 1.0000 पर आ जाएगा।
• अलर्ट इंटीग्रेशन: इन क्रिटिकल पॉइंट्स को एक्सचेंज के ऑर्डर बुक पार्सर से लिंक करें। जैसे ही मार्केट प्राइस व्हेल के क्रैश पॉइंट के 1.5% के दायरे में आए, सिस्टम को तुरंत एक हाई-प्रायोरिटी सिग्नल जनरेट करना चाहिए।
• कमाई का रास्ता चुनना:
  • बड़ी कैपिटल वाली टीमों के लिए: एक एक्टिव MEV बॉट चालू करना, फ्लैश लोन की पाइपलाइन रेडी रखना और प्राइवेट रिले के ज़रिए ब्लॉक स्पेस के लिए बिडिंग करना।
  • रिटेल ट्रेडर्स के लिए: फ्यूचर्स/परपेचुअल मार्केट्स पर एग्रेसिव शॉर्ट पोजीशन ओपन करना, ताकि उस वक्त होने वाले भारी मार्केट डंप का फ़ायदा उठाया जा सके जब बॉट्स व्हेल के कोलैटरल को मार्केट में ज़बरदस्ती डंप करना शुरू करेंगे।

DeFi में लिक्विडेशन का मार्केट पूरी तरह से प्योर मैथ और एक्ज़ीक्यूशन की रफ़्तार का खेल है। जो बंदा ब्लॉकचेन के स्टेट को रीड करना और क्रिटिकल पॉइंट्स की कैलकुलेशन को ऑटोमेट करना जानता है, वह चार्ट पर लकीरें खींचने वाले आम टेक्निकल एनालिसिस के दिग्गजों से हमेशा मीलों आगे रहेगा।