Memecoins पर Stat-Arb: Whales को ट्रैक करने का स्क्रिप्ट

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

आज देखेंगे कि पाइथॉन (Python) की मदद से इस पागलपन पर स्टैटिस्टिकल आर्बिट्राज कैसे चलाना है, ब्लॉकचेन से सही व्हेल वॉलेट्स कैसे ढूंढने हैं और टोकन के आसमान छूने से पहले उनके ट्रेड्स को कैसे कॉपी करना है, ताकि भीड़ के लिए सिर्फ खाली हाथ न बचें।

मेम-कॉइंस पर Smart Money का ढांचा: ये लोग कौन हैं?

डेक्स (DEX) पर "स्मार्ट मनी" तीन कैटगरी में बंटी होती है। इसे समझे बिना तुम्हारा स्क्रिप्ट सिर्फ फीस में ही पूरा डिपॉजिट उड़ा देगा। वैसे, Solana या Base पर तो फीस नाममात्र है... लेकिन स्लिपेज (slippage) तुम्हें फिर भी लिक्विडेट कर देगा।

• इंसाइडर्स (डेवलपर्स और उनके दोस्त): ये टोकन डिप्लॉय होते ही पहले सेकंड में स्नाइप करते हैं। इन्हें कॉन्ट्रैक्ट कोड और मार्केटिंग का टाइम पता होता है। अक्सर इनके वॉलेट मिक्सर से जुड़े होते हैं, लेकिन हम इन्हें "टोटल सप्लाई के 5% की पहली बाय ट्रांजैक्शन" के पैटर्न से पकड़ लेते हैं।
• कस्टम सॉफ्टवेयर वाले स्नाइपर्स: ये लोग फास्ट RPC नोड्स पर बैठते हैं और हर काम के पूल को तुरंत खरीद लेते हैं।
• ट्रेंड वेल्स (Whales): ये सोशल सेंटीमेंट को ट्रैक करते हैं और शुरुआती स्टेज में ही टोकन में 10-20 ETH / 500 SOL डाल देते हैं, जिससे चार्ट पर बड़ी हरी कैंडल बनती हैं। इनके पीछे जाना सबसे सेफ है।

सबसे बड़ी गलती नंबर 1: Ethereum के मेमपूल में सैंडविच अटैक करने वाले MEV बॉट्स को कॉपी करने की कोशिश करना। इनके Flashbots बंडल्स को कभी पछाड़ नहीं पाओगे। स्क्रिप्ट सिर्फ ट्रांजैक्शन भेजेगी, रिवर्ट होगी और गैस फीस में पैसा डूबेगा। एक हफ्ते पहले Base पर ऐसा ही रिवर्ट मिला था जब राउटर कॉन्ट्रैक्ट्स को फिल्टर करना भूल गए थे। सीधा 50 डॉलर हवा में उड़ गए।

"मोटी व्हेल" को कैसे ट्रैक करें: पार्सिंग का लॉजिक

प्लान सिंपल है। पिछले कुछ दिनों के डिसेंट्रलाइज्ड एक्सचेंजों (जैसे Base पर Uniswap v3 या Solana पर Raydium) के लॉग्स को पार्स करना है। ऐसे वॉलेट ढूंढने हैं जिन्होंने मेम-कॉइंस पर कम से कम 5-10x बनाया हो।

इसके लिए हजारों डॉलर के पेड API की जरूरत नहीं है। QuickNode या Alchemy का फ्री टियर और ब्लॉकचेन लॉग्स की बेसिक समझ काफी है। DEX पर हर बाय से Swap इवेंट ट्रिगर होता है। ये एड्रेस निकालो, डेटाबेस में डालो (सिंपल लॉग्स के लिए MariaDB ठीक है, Postgres का तामझाम नहीं चाहिए) और उनका PnL चेक करो।

पहले सोचा था कि Rust में इनलाइन असेंबलर से पार्सर लिखूं ताकि स्पीड सुपरफास्ट हो... लेकिन फिर छोड़ दिया। MVP के लिए इतनी मेहनत बेकार है। web3.py लाइब्रेरी के साथ Python इसे आराम से संभाल लेगा।

वर्किंग स्क्रिप्ट लिखना: ट्रैकर और ऑटो-बायर

नीचे EVM नेटवर्क्स (Base, Arbitrum, BSC) के लिए रेडी स्क्रिप्ट है। यह RPC नोड को सुनता है, टारगेट व्हेल के वॉलेट को फिल्टर करता है और जैसे ही वह swapExactTokensForTokens या ऐसा ही कुछ कॉल करता है, तुरंत वैसा ही बाय ऑर्डर भेज देता है।

L2 में कोई मेमपूल नहीं होता। बिल्कुल नहीं। सब कुछ FCFS (First Come, First Served) पर चलता है। जो पहले आया, माल उसका। इसलिए तुम्हारी नोड की स्पीड ही सब कुछ है।

Python

import time
import os
from web3 import Web3
from eth_account import Account
# कॉन्फिग। अपना डेटा डालो भाई।
RPC_URL = "https://mainnet.base.org"  # प्राइवेट नोड यूज करो, पब्लिक वाली एक मिनट में क्रैश हो जाएगी
PRIVATE_KEY = "ТВОЙ_ПРИВАТНИК_СЮДА_НЕ_ПАЛИ_ЕГО"
SMART_MONEY_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e" # जिस व्हेल को ट्रैक करना है उसका एड्रेस
ROUTER_ADDRESS = "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24" # Base पर Uniswap v3 राउटर का एग्जांपल
# WETH और टारगेट टोकन एड्रेस (इसे व्हेल की ट्रांजैक्शन से निकालेंगे)
WETH_ADDRESS = "0x4200000000000000000000000000000000000006"
w3 = Web3(Web3.HTTPProvider(RPC_URL))
account = Account.from_key(PRIVATE_KEY)
# केवल स्वैप के लिए मिनिमम राउटर ABI
ROUTER_ABI = [
    {
        "inputs": [
            {"internalType": "uint256", "name": "amountOutMin", "type": "uint256"},
            {"internalType": "address[]", "name": "path", "type": "address[]"},
            {"internalType": "address", "name": "to", "type": "address"},
            {"internalType": "uint256", "name": "deadline", "type": "uint256"}
        ],
        "name": "swapExactETHForTokens",
        "outputs": [{"internalType": "uint256[]", "name": "amounts", "type": "uint256[]"}],
        "stateMutability": "payable",
        "type": "function"
    }
]
router_contract = w3.eth.contract(address=ROUTER_ADDRESS, abi=ROUTER_ABI)
def buy_token(target_token_address, eth_amount_to_spend):
    """व्हेल के पीछे सीधे मार्केट प्राइस पर टोकन बाय करना"""
    nonce = w3.eth.get_transaction_count(account.address)
    
    # ट्रांजैक्शन बनाना। गैस मार्जिन के साथ रखना, वरना प्राइस मूव होने पर रिवर्ट हो जाएगा
    tx = router_contract.functions.swapExactETHForTokens(
        0, # amountOutMin = 0. हां, 100% स्लिपेज। मेम पर इसके बिना ऑर्डर फिल नहीं होगा
        [WETH_ADDRESS, target_token_address],
        account.address,
        int(time.time()) + 60
    ).build_transaction({
        'from': account.address,
        'value': w3.to_wei(eth_amount_to_spend, 'ether'),
        'gas': 250000,
        'maxFeePerGas': w3.eth.gas_price * 2, # सबसे पहले एंट्री के लिए एवरेज गैस से डबल रखना
        'maxPriorityFeePerGas': w3.to_wei(2, 'gwei'),
        'nonce': nonce,
        'chainId': 8453 # Base chain id
    })
    
    signed_tx = w3.eth.account.sign_transaction(tx, private_key=PRIVATE_KEY)
    tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
    print(hex(tx_hash)) # प्रॉफिट आया या नहीं? एक्सप्लोरर पर चेक करो...
def monitor_wallet():
    print("स्क्रिप्ट चालू है। देख रहे हैं व्हेल कहां पैसा डाल रही है...")
    last_block = w3.eth.block_number
    
    while True:
        try:
            current_block = w3.eth.block_number
            if current_block > last_block:
                for block_num in range(last_block + 1, current_block + 1):
                    block = w3.eth.get_block(block_num, full_transactions=True)
                    for tx in block.transactions:
                        # चेक करना कि ट्रांजैक्शन व्हेल ने भेजी है या नहीं
                        if tx['from'].lower() == SMART_MONEY_ADDRESS.lower():
                            print("भाई साहब! व्हेल ने मूव किया!")
                            
                            # चेक करना कि राउटर हिट हुआ है या नहीं
                            if tx['to'] and tx['to'].lower() == ROUTER_ADDRESS.lower():
                                # रियल केस में इनपुट डेटा पार्स करके टोकन एड्रेस निकालना होगा
                                # एग्जांपल के लिए एक डमी शिटकॉइन एड्रेस रख लेते हैं:
                                target_meme = "0x1111111111111111111111111111111111111111" 
                                
                                print(f"व्हेल को कॉपी कर रहे हैं। बाइंग: {target_meme}")
                                buy_token(target_meme, 0.01) # टेस्ट के लिए छोटे अमाउंट से एंट्री
                                
                last_block = current_block
            time.sleep(0.5) # नोड ब्लॉक से बचने के लिए रेट लिमिट
        except Exception as e:
            # रात के 3 बजे कोडर सो सकता है, एरर नहीं
            print(f"कुछ क्रैश हुआ, लूप रीस्टार्ट कर रहे हैं: {e}")
            time.sleep(1)
if __name__ == "__main__":
    monitor_wallet()

रिस्क, कमियां और आप लिक्विडिटी कैसे बन जाते हैं

जब तक तुम्हारा स्क्रिप्ट प्रोसेस करेगा और बैलेंस चेक करेगा, तब तक व्हेल अपने फॉलोअर्स को चूना लगा चुकी होगी। हनीपॉट (Honeypot) का खेल तो पुराना है।

स्कैम ऐसे चलता है:

1. व्हेल (या इंसाइडर) एक ऐसा टोकन डिप्लॉय करता है जिसके कोड में सिर्फ चुनिंदा एड्रेस को ही बेचने की परमिशन होती है।
2. वह खुद ब्लॉकचेन पर सबके सामने उस टोकन को खरीदता है।
3. तुम्हारा स्क्रिप्ट इस "स्मार्ट मनी" ट्रेड को देखता है, उसी ब्लॉक में घुसता है और बाय कर लेता है...

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

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

जब सिमुलेशन की बात छिड़ ही गई है, तो जरा इस सिरदर्द को थोड़ा डिटेल में समझते हैं। ज्यादातर नौसिखियों को लगता है: "मैं एक लॉग पार्सर लिखूंगा, सीधे मार्केट ऑर्डर मारूंगा और अंधा पैसा छापूँगा।" भाई, ऐसा नहीं होता।
बिना प्री-ट्रेड सिमुलेशन के आप स्कैमर्स के लिए बस एक मुफ्त की दावत हो।

प्री-ट्रेड सिमुलेशन: हनीपॉट (Honeypot) में फंसने से कैसे बचें

जब कोई व्हेल किसी नए कॉन्ट्रैक्ट में एंट्री लेती है, तो आपके स्क्रिप्ट को आंख बंद करके सीधे वह एड्रेस कॉपी नहीं करना चाहिए। पहले यह चेक करना जरूरी है कि उस शिटकॉइन को वापस बेचा भी जा सकता है या नहीं। इसके लिए eth_call मेथड का इस्तेमाल होता है। हम लाइव नेटवर्क पर ट्रांजैक्शन भेजे बिना, लोकल नोड पर ही swapExactTokensForETH फंक्शन कॉल का सिमुलेशन रन करते हैं।
अगर नोड कोई रिवर्ट (एरर) फेंकता है, तो टोकन सीधे ब्लैकलिस्ट में जाता है। स्क्रिप्ट उसे छोड़ देगी और आपका फंड सेफ रहेगा।
यह रहा कोड का वह टुकड़ा जिसे आपको ठीक buy_token फंक्शन से पहले इंजेक्ट करना है। यहाँ मैंने नेटवर्क फोर्क के साथ पूरा सिमुलेटर तैयार नहीं किया है। वैसे Hardhat/Anvil के जरिए ऐसा करना ही सबसे सही तरीका है, पर अभी हम बस जुगाड़ से एक क्विक स्क्रिप्ट लिख रहे हैं।

Python

def check_honeypot(token_address):
    """
    टोकन का स्कैन। बाय और सेल का सिमुलेशन।
    अगर कॉन्ट्रैक्ट सेल ब्लॉक करता है, तो यह स्कैम है।
    """
    # चेक करने के लिए राउटर यूज कर रहे हैं। बिल्कुल छोटी अमाउंट डाल रहे हैं।
    test_amount_in = w3.to_wei(0.001, 'ether')
    
    try:
        # eth_call के जरिए बाय सिमुलेट कर रहे हैं
        # बस यह देख रहे हैं कि कॉन्ट्रैक्ट लेवल पर एरर तो नहीं आ रहा
        router_contract.functions.swapExactETHForTokens(
            0,
            [WETH_ADDRESS, token_address],
            account.address,
            int(time.time()) + 60
        ).call({'from': account.address, 'value': test_amount_in})
        
        # वैसे यहाँ SELL भी सिमुलेट करना चाहिए।
        # पर उसके लिए बैलेंस में टोकन होने चाहिए या लोकल नेटवर्क फोर्क चाहिए।
        # रात के 3 बजे सिर्फ बाय सिमुलेशन चेक भी काफी है।
        # वैसे भी ज्यादातर घटिया हनीपॉट राउटर हिट करते ही दम तोड़ देते हैं।
        return True
    except Exception as e:
        print(f"ALERT! टोकन {token_address} सिमुलेशन में फेल रहा: {e}। इस कचरे को छोड़ो।")
        return False

एग्जिट स्ट्रेटेजी: प्रॉफिट बुक करके घर लाना

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

• 2x का लेवल (+100%): स्क्रिप्ट ऑटोमेटिकली आपकी पोजीशन का ठीक 50% हिस्सा बेच देगी। बस खेल खत्म, आपका प्रिंसिपल अमाउंट बाहर आ गया और अब आप फ्री की राइड पर हो। इसके बाद ट्रेड को होल्ड करना मानसिक रूप से सौ गुना आसान हो जाता blink।
• 3x का लेवल (+200%): बचे हुए बैग में से 25% हिस्सा और डंप कर दो।
• ट्रेलिंग स्टॉप (Trailing Stop): बची हुई पोजीशन (मून बैग) ट्रेंड के साथ चलती रहेगी। जैसे ही प्राइस अपने लोकल पीक से 20% नीचे गिरेगा, स्क्रिप्ट तुरंत मार्केट ऑर्डर पर सब कुछ क्लोज कर देगी।

मैदान की सीधी बात (Alpha): अगर आपकी पोजीशन बड़ी है, तो सेल करते समय amountOutMin को कभी भी जीरो पर सेट न करें। अगर आप $2000 की लिक्विडिटी वाले पूल में $500 के टोकन एक साथ डंप करने की कोशिश करेंगे, तो MEV बॉट्स फ्रंटरनिंग करके आपको कच्चा चबा जाएंगे। भारी स्लिपेज (slippage) के कारण आपकी स्क्रिप्ट को सिर्फ कौड़ियाँ मिलेंगी। हमेशा छोटे-छोटे ऑर्डर्स में टुकड़ों में बेचें।

शुरुआत के लिए स्मार्ट मनी एड्रेस कहाँ ढूँढें?

बिना सही एड्रेस के स्क्रिप्ट सिर्फ बेकार कोड का ढेर है। व्हेल्स के वॉलेट कहाँ मिलेंगे?

• Dextools / Dexscreener: पिछले 24 घंटे के टॉप गेनर्स की लिस्ट खोलें। Top Traders या Transactions वाले टैब पर जाएँ। ऐसे वॉलेट ढूंढें जिन्होंने बिल्कुल शुरुआत में (ब्लॉक 0-100) एंट्री मारी और बिल्कुल टॉप पर प्रॉफिट बुक किया। उन एड्रेसेस को कॉपी कर लें।
• DeBank / Arkham: कॉपी किया हुआ एड्रेस वहाँ पेस्ट करें। उस ट्रेडर का विन रेट चेक करें। अगर उसके वॉलेट में $100k+ का बैलेंस है, जो उसने शिटकॉइन्स में सिर्फ $500 के शुरुआती कैपिटल से बनाया है, तो समझो अपना काम हो गया। उसे अपने स्क्रिप्ट के SMART_MONEY_ADDRESSES एरे में ऐड कर लें।

काम की बात

मीम कॉइन्स में स्टैटिस्टिकल आर्बिट्राज और कॉपी-ट्रेडिंग कोई पैसा छापने की जादुई मशीन नहीं है। यह पूरी तरह स्पीड की रेस और स्कैम्स को फिल्टर करने का खेल है। जब तक आपकी स्क्रिप्ट किसी पब्लिक RPC नोड पर चल रही है, आप हमेशा पीछे ही रहेंगे। अगर मार्केट में असली एज (edge) चाहिए, तो प्राइवेट नोड एक्सेस लें (जैसे Solana के लिए Jito या फास्ट ट्रांजैक्शन सपोर्ट करने वाले कस्टम EVM नोड्स), अपनी चेकिंग लॉजिक को बेहतर बनाएं और रिस्क को कड़ाई से मैनेज करें।
और सबसे जरूरी बात — शिटकॉइन्स में कभी भी वह पैसा न लगाएं जिसे आप खोने की हिम्मत नहीं रखते। कल को कोई प्रोजेक्ट रिवर्ट मार देगा, डेवलपर लिक्विडिटी खींच लेगा (rug pull) और फिर कोई भी स्क्रिप्ट आपके फंड्स नहीं बचा पाएगी।