MEV बॉट लाभ और गैस शुल्क: आर्बिट्राज रणनीति गाइड

MEV की शुद्ध अर्थनीति ट्रांजैक्शन ब्लॉक के लिए होने वाली उस खूंखार प्रतियोगिता पर टिकी है जहाँ नेटवर्क की एक मिलीसेकंड की देरी भी आपका सारा संभावित मुनाफा चट कर जाती है। एथेरियम या लेयर 2 EVM नेटवर्क पर अपना खुद का बॉट चलाना अब आसान पैसों का खेल नहीं रहा। इस बाजार पर उन विशेष सर्चर्स का कब्जा है जो वैलिडेटर नोड्स के ठीक बगल में फ्रैंकफर्ट और टोक्यो के डेटा केंद्रों में सर्वर किराए पर लेते हैं।

वास्तविक आंकड़े और लाभप्रदता

घर के सर्वर या किसी साधारण क्लाउड VPS से चलाया जाने वाला अकेला बॉट गैस ऑक्शन के चक्कर में 95% मामलों में घाटे में ही रहता है। मुनाफा पूरी तरह आपकी रणनीति पर निर्भर करता है:

• एटॉमिक आर्बिट्रेज (Atomic Arbitrage): ट्रेड मार्जिन अब घटकर एक प्रतिशत के भी छोटे हिस्से पर आ गया है। उतार-चढ़ाव के दौर में एक सफल बॉट का शुद्ध दैनिक लाभ $100 से $3,000 के बीच रहता है। पूंजी डूबने का जोखिम शून्य है क्योंकि पूरा ट्रांजैक्शन एक सिंगल एटॉमिक स्मार्ट कॉन्ट्रैक्ट में पैक होता है: यदि शर्तें मैच नहीं हुईं, तो पूरा चेन रीवरट हो जाता है।
• सैंडविच अटैक्स (Sandwich Attacks): Uniswap v2 या ऐसे ही अन्य AMM पर कम लिक्विडिटी वाले पेयर्स पर सैद्धांतिक मुनाफा अधिक, यानी रोजाना $500 से $10,000 तक होता है। लेकिन वास्तविकता काफी कठोर है। प्रतिद्वंद्वी बॉट प्राइवेट ट्रांजैक्शन पूल के जरिए अपनी कतार बनाते हैं और वैलिडेटर को मिलने वाली घूस को मात देते हुए आगे निकल जाते हैं।
• लिक्विडेशन (Liquidations): Aave जैसे लेंडिंग प्रोटोकॉल्स का स्पॉट मार्केट भारी मुनाफा देता है, लेकिन इसके लिए कर्ज चुकाने और पोजीशन तुरंत सेटल करने के वास्ते लाखों डॉलर की लिक्विडिटी चाहिए होती है। अकेले काम करने वालों के लिए यहाँ कुछ नहीं है।

गैस खर्च की संरचना और बिल्डर्स के साथ काम करना

MEV बॉट लॉन्च करते समय आपका सबसे बड़ा खर्च सफल ट्रांजैक्शन नहीं, बल्कि असफल प्रयास और गैस प्रायोरिटी ऑक्शन (GPA) होते हैं।

• पब्लिक मेम्पूल: प्राइवेट रिले को दरकिनार करके ट्रांजैक्शन भेजना घाटे की पक्की गारंटी है। एक सामान्य बॉट किसी पीड़ित का ट्रांजैक्शन देखकर उससे अधिक गैस के साथ अपना ट्रांजैक्शन भेजता है, लेकिन प्रतिद्वंद्वी बॉट प्राइवेट RPC के जरिए उसे पहले ही लपक लेते हैं। नतीजा यह होता है कि आपका ट्रांजैक्शन सबसे खराब भाव पर एग्जीक्यूट होता है या फिर ब्लॉकचेन में असली गैस फूंकते हुए रीवरट हो जाता है।
• ब्लॉक बिल्डर्स और फ्लैशबॉट्स (Flashbots): आधुनिक आर्बिट्रेज eth_sendBundle के जरिए चलता है। आप कई ट्रांजैक्शन का एक बंडल बनाते हैं और उसे सीधे ब्लॉक बिल्डर्स (Beaverbuild, Titan, Flashbots) के पास भेज देते हैं।
• असफलता का शुल्क: प्राइवेट बंडल का फायदा यह है कि आर्बिट्रेज फेल होने पर ट्रांजैक्शन ब्लॉक में जाता ही नहीं है। चूके हुए निशाने के लिए आपको नेटवर्क फीस नहीं चुकानी पड़ती। नुकसान यह है कि वैलिडेटर सीधे मिलने वाली घूस (coinbase.transfer) के रूप में मुनाफे का बड़ा हिस्सा डकार जाता है और डेवलपर के हाथ कुल ग्रॉस प्रॉफिट का मात्र 5% से 15% ही लगता है।

MEV रणनीतियों की मेट्रिक्स तालिका

Python में प्राइवेट बंडल भेजने का उदाहरण

नीचे web3.py लाइब्रेरी का उपयोग करके फ्लैशबॉट्स-संगत प्रदाता के माध्यम से बंडल भेजने का एक काम करने वाला पाइथन स्क्रिप्ट ढांचा दिया गया है। कोड को अनावश्यक abstractions से मुक्त किया गया है।

import os
from eth_account import Account
from eth_account.signers.local import LocalAccount
from web3 import Web3
from flashbots import flashbot
# रिले अनुरोधों पर हस्ताक्षर करने की कुंजी (फ्लैशबॉट्स में प्रतिष्ठा)।
# उस कुंजी का उपयोग न करें जिसमें आपके असली फंड रखे हों।
signature_account: LocalAccount = Account.from_key(os.environ["FLASHBOTS_SIGNER_KEY"])
# ट्रांजैक्शन भेजने वाले की कुंजी
sender: LocalAccount = Account.from_key(os.environ["SENDER_PRIVATE_KEY"])
w3 = Web3(Web3.HTTPProvider(os.environ["ETH_NODE_URL"]))
flashbot(w3, signature_account, "https://relay-sepolia.flashbots.net")
def build_signed_tx(nonce: int) -> bytes:
    base_fee = w3.eth.get_block("latest")["baseFeePerGas"]
    tx = {
        "to": sender.address,          # उदाहरण: खुद को ट्रांसफर
        "value": 0,
        "gas": 21_000,
        "maxFeePerGas": base_fee * 2 + Web3.to_wei(2, "gwei"),
        "maxPriorityFeePerGas": Web3.to_wei(2, "gwei"),
        "nonce": nonce,
        "chainId": w3.eth.chain_id,
        "type": 2,
    }
    return sender.sign_transaction(tx).rawTransaction  # नए वर्जन्स में: .raw_transaction
def send_private_bundle(target_block: int):
    nonce = w3.eth.get_transaction_count(sender.address)
    bundle = [{"signed_transaction": build_signed_tx(nonce)}]
    # भेजने से पहले सिमुलेशन
    w3.flashbots.simulate(bundle, target_block)
    result = w3.flashbots.send_bundle(bundle, target_block_number=target_block)
    result.wait()  # जब तक target_block प्रोसेस न हो जाए, प्रतीक्षा करें
    try:
        return result.receipts()
    except Exception:
        return None  # बंडल ब्लॉक में शामिल नहीं हुआ: अगले ब्लॉक पर दोबारा प्रयास कर सकते हैं
if __name__ == "__main__":
    target = w3.eth.block_number + 1
    receipts = send_private_bundle(target)
    print("ब्लॉक में शामिल हो गया" if receipts else "बंडल शामिल नहीं हुआ, अगले ब्लॉक पर पुनः प्रयास करें")

बंडल केवल एक लक्षित ब्लॉक के लिए मान्य होता है, इसलिए व्यावहारिक रूप से कई लगातार ब्लॉकों पर लूप में भेजना जरूरी होता है। ब्लॉक में शामिल न होना कोई त्रुटि नहीं है: असली मुकाबला बिल्डर को मिलने वाली टिप की रकम को लेकर होता है।

खुद के बॉट का मुनाफा सीधे तौर पर इंफ्रास्ट्रक्चर की लागत पर निर्भर करता है। डेटा सेंटर में वैलिडेटर के साथ रैक में डेडिकेटेड सर्वर किराए पर लेने का खर्च प्रति माह $500 से शुरू होता है। इस तरह के हार्डवेयर एक्सिलरेशन के बिना, आपका बॉट प्रतिद्वंद्वियों से पहले पूल की स्थिति को शारीरिक रूप से कैलकुलेट ही नहीं कर पाएगा। जीतता वही है जिसके पास वैलिडेटर तक सबसे छोटा केबल और सबसे सटीक स्प्रेड-फाइंडिंग एल्गोरिदम हो।

फ्लैश लोन (Flash loans) बिना किसी बड़े शुरुआती पूंजी के बड़े पैमाने पर आर्बिटراج ऑपरेशन चलाने का मौका देते हैं, जिसमें बिना किसी गारंटी (unsecured borrowing) के एक ही ट्रांजैक्शन के भीतर उधार लिया जाता है और घाटा होने पर ट्रांजैक्शन अपने आप रद्द (rollback) हो जाती है।

फ्लैश लोन और स्मार्ट कॉन्ट्रैक्ट आर्किटेक्चर

आर्बिटراج के लिए लाखों डॉलर की अपनी पूंजी होना बिल्कुल जरूरी नहीं है। Aave v3 या Balancer पूल्स के साथ इंटीग्रेशन कॉन्ट्रैक्ट्स आपको एक ही ट्रांजैक्शन के दायरे में बिना जमानत के फ्लैश लोन लेने की अनुमति देते हैं। आपका बॉट एसेट उधार लेता है, उसे DEX पेयर्स के जरिए गुजारता है, 0.09% फीस काटकर कर्ज चुकाता है और बाकी बचा मुनाफा क्रिएटर के बैलेंस में ले आता है। यदि सभी गणनाओं के बाद बैलेंस माइनस में जाता है, तो पूरा ट्रांजैक्शन revert के जरिए रद्द हो जाता है और जारीकर्ता (issuer) को केवल फंक्शन कॉल करने की गैस फीस का ही नुकसान होता है।

Solidity में आर्बिटراج कॉन्ट्रैक्ट लिखने के लिए EVM बाइटकोड के तहत सख्त ऑप्टिमाइज़ेशन की जरूरत होती है। SafeERC20 के जरिए मानक ERC-20 इंटरफेस का उपयोग करने से अतिरिक्त जांच (checks) जुड़ जाती हैं, जो ट्रांजैक्शन लिमिट चेक करते समय गैस की मूल्यवान यूनिट्स को खा जाती हैं। अनुभवी डेवलपर्स call के जरिए सीधे लो-लेवल कॉल लिखते हैं, जिससे स्थायी मेमोरी (SLOAD/SSTORE) में पढ़ने और लिखने के ऑपरेशन कम से कम होते हैं।

Solidity टेम्पलेट का उदाहरण

नीचे Uniswap V2 पूल्स के लिए Aave V3 फ्लैश लोन पर आधारित एक टेम्पलेट दिया गया है, जो किसी बाहरी लाइब्रेरी के बिना है:

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;
interface IERC20 {
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
}
/// Aave V3: सिंगल एसेट का फ्लैश लोन
interface IPool {
    function flashLoanSimple(
        address receiverAddress,
        address asset,
        uint256 amount,
        bytes calldata params,
        uint16 referralCode
    ) external;
}
interface IUniswapV2Pair {
    function token0() external view returns (address);
    function getReserves() external view returns (uint112, uint112, uint32);
    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external;
}
/// Aave V3 फ्लैश लोन पर आर्बिटراج: asset -> tokenB (pair1) -> asset (pair2).
/// Uniswap V2 प्रकार के पूल्स के लिए उदाहरण। ऑडिट नहीं किया गया है।
contract FlashArbitrage {
    error Unauthorized();
    error InvalidCaller();
    error InvalidInitiator();
    error TransferFailed();
    error ApproveFailed();
    error InsufficientProfit(uint256 balanceAfter, uint256 required);
    address private immutable OWNER;
    IPool private immutable POOL;
    constructor(address aavePool) {
        OWNER = msg.sender;
        POOL = IPool(aavePool); // आवश्यक नेटवर्क के PoolAddressesProvider से Pool का पता लें
    }
    modifier onlyOwner() {
        if (msg.sender != OWNER) revert Unauthorized();
        _;
    }
    /// एंट्री पॉइंट। `asset` टोकन की `amount` मात्रा उधार लेता है और executeOperation में लूप शुरू करता है।
    function executeArbitrage(
        address asset,
        uint256 amount,
        address tokenB,
        address pair1,
        address pair2,
        uint256 minProfit
    ) external onlyOwner {
        bytes memory params = abi.encode(tokenB, pair1, pair2, minProfit);
        POOL.flashLoanSimple(address(this), asset, amount, params, 0);
    }
    /// Aave V3 कॉलबैक। लोन जारी होने के बाद पूल द्वारा कॉल किया जाता है।
    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,
        address initiator,
        bytes calldata params
    ) external returns (bool) {
        // 1. कॉलबैक को केवल Aave पूल ही कॉल कर सकता है...
        if (msg.sender != address(POOL)) revert InvalidCaller();
        // 2. ...और केवल इसी कॉन्ट्रैक्ट के अनुरोध पर
        if (initiator != address(this)) revert InvalidInitiator();
        (address tokenB, address pair1, address pair2, uint256 minProfit) =
            abi.decode(params, (address, address, address, uint256));
        // बैलेंस में उधार ली गई राशि पहले से शामिल है
        uint256 balanceBefore = IERC20(asset).balanceOf(address(this));
        uint256 amountB = _swap(pair1, asset, amount);
        _swap(pair2, tokenB, amountB);
        // मुनाफा = balanceAfter - balanceBefore - premium (लोन फीस)
        uint256 balanceAfter = IERC20(asset).balanceOf(address(this));
        uint256 required = balanceBefore + premium + minProfit;
        if (balanceAfter < required) revert InsufficientProfit(balanceAfter, required);
        // Aave transferFrom के जरिए खुद कर्ज वसूलता है, इसलिए approve की आवश्यकता है
        _safeApprove(asset, address(POOL), amount + premium);
        return true;
    }
    function withdraw(address token, uint256 amount) external onlyOwner {
        _safeTransfer(token, OWNER, amount);
    }
    function _swap(address pair, address tokenIn, uint256 amountIn) private returns (uint256 amountOut) {
        (uint256 r0, uint256 r1, ) = IUniswapV2Pair(pair).getReserves();
        bool zeroForOne = tokenIn == IUniswapV2Pair(pair).token0();
        (uint256 reserveIn, uint256 reserveOut) = zeroForOne ? (r0, r1) : (r1, r0);
        // Uniswap V2 फॉर्मूला (0.3% फीस)
        uint256 amountInWithFee = amountIn * 997;
        amountOut = (amountInWithFee * reserveOut) / (reserveIn * 1000 + amountInWithFee);
        _safeTransfer(tokenIn, pair, amountIn);
        IUniswapV2Pair(pair).swap(
            zeroForOne ? 0 : amountOut,
            zeroForOne ? amountOut : 0,
            address(this),
            "" // खाली data: यह सामान्य स्वैप है, फ्लैश स्वैप नहीं
        );
    }
    function _safeTransfer(address token, address to, uint256 amount) private {
        if (token.code.length == 0) revert TransferFailed();
        (bool ok, bytes memory data) = token.call(abi.encodeCall(IERC20.transfer, (to, amount)));
        if (!ok || (data.length != 0 && !abi.decode(data, (bool)))) revert TransferFailed();
    }
    function _safeApprove(address token, address spender, uint256 amount) private {
        if (token.code.length == 0) revert ApproveFailed();
        (bool ok, bytes memory data) = token.call(abi.encodeCall(IERC20.approve, (spender, amount)));
        if (!ok || (data.length != 0 && !abi.decode(data, (bool)))) revert ApproveFailed();
    }
}

AWS का इंफ्रास्ट्रक्चर डेड-एंड

Amazon Web Services या Google Cloud जैसे वर्चुअल सर्वर पर सर्च बॉट होस्ट करना आपके बजट की बर्बादी की पूरी गारंटी है। वर्चुअलाइजेशन नेटवर्क स्टैक में डिले (latency) पैदा करता है, और मेम्पूल के अत्यधिक लोड के समय साझा कम्यूनिकेशन चैनल पैकेट लॉस का शिकार हो जाते हैं।

एक प्रतिस्पर्धी सेटअप के लिए हाई सिंगल-कोर क्लॉक स्पीड वाले सीपीयू, स्थानीय Geth या Reth नोड के लिए तेज NVMe स्टोरेज और फ्रैंकफर्ट के डेटा सेंटर्स तक सीधे गीगाबिट चैनल वाले फिजिकल डेडिकेटेड सर्वर (bare-metal) की आवश्यकता होती है। अपना खुद का लाइटवेट नोड चलाना अनिवार्य है, क्योंकि Infura या Alchemy जैसे पब्लिक RPC प्रोवाइडर नए ब्लॉकों को डिलीवर करने की गति को कृत्रिम रूप से धीमा कर देते हैं और पेंडिंग ट्रांजैक्शन के नोटिफिकेशन में महत्वपूर्ण 100-300 मिलीसेकंड की देरी करते हैं।

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